diff --git a/libweave/include/weave/cloud.h b/libweave/include/weave/cloud.h
index daa39f1..ade4247 100644
--- a/libweave/include/weave/cloud.h
+++ b/libweave/include/weave/cloud.h
@@ -9,7 +9,7 @@
 
 #include <base/callback.h>
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -27,8 +27,7 @@
       base::Callback<void(RegistrationStatus satus)>;
   using OnCloudRequestCallback =
       base::Callback<void(const base::DictionaryValue& response)>;
-  using OnCloudRequestErrorCallback =
-      base::Callback<void(const chromeos::Error* error)>;
+  using OnCloudRequestErrorCallback = base::Callback<void(const Error* error)>;
 
   // Sets callback which is called when registration state is changed.
   virtual void AddOnRegistrationChangedCallback(
@@ -44,19 +43,19 @@
   // Registers the device.
   // Returns a device ID on success.
   virtual std::string RegisterDevice(const std::string& ticket_id,
-                                     chromeos::ErrorPtr* error) = 0;
+                                     ErrorPtr* error) = 0;
 
   // Updates basic device information.
   virtual bool UpdateDeviceInfo(const std::string& name,
                                 const std::string& description,
                                 const std::string& location,
-                                chromeos::ErrorPtr* error) = 0;
+                                ErrorPtr* error) = 0;
 
   // Updates base device config.
   virtual bool UpdateBaseConfig(const std::string& anonymous_access_role,
                                 bool local_discovery_enabled,
                                 bool local_pairing_enabled,
-                                chromeos::ErrorPtr* error) = 0;
+                                ErrorPtr* error) = 0;
 
   // Updates GCD service configuration. Usually for testing.
   virtual bool UpdateServiceConfig(const std::string& client_id,
@@ -64,7 +63,7 @@
                                    const std::string& api_key,
                                    const std::string& oauth_url,
                                    const std::string& service_url,
-                                   chromeos::ErrorPtr* error) = 0;
+                                   ErrorPtr* error) = 0;
 
  protected:
   virtual ~Cloud() = default;
diff --git a/libweave/include/weave/command.h b/libweave/include/weave/command.h
index 0533afa..e3d35a7 100644
--- a/libweave/include/weave/command.h
+++ b/libweave/include/weave/command.h
@@ -8,7 +8,7 @@
 #include <string>
 
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -73,12 +73,12 @@
   // Updates the command progress. The |progress| should match the schema.
   // Returns false if |progress| value is incorrect.
   virtual bool SetProgress(const base::DictionaryValue& progress,
-                           chromeos::ErrorPtr* error) = 0;
+                           ErrorPtr* error) = 0;
 
   // Updates the command results. The |results| should match the schema.
   // Returns false if |results| value is incorrect.
   virtual bool SetResults(const base::DictionaryValue& results,
-                          chromeos::ErrorPtr* error) = 0;
+                          ErrorPtr* error) = 0;
 
   // Aborts command execution.
   virtual void Abort() = 0;
diff --git a/libweave/include/weave/commands.h b/libweave/include/weave/commands.h
index 37ca095..68751ac 100644
--- a/libweave/include/weave/commands.h
+++ b/libweave/include/weave/commands.h
@@ -9,7 +9,7 @@
 
 #include <base/callback.h>
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/command.h>
 
 namespace weave {
@@ -36,7 +36,7 @@
   virtual bool AddCommand(const base::DictionaryValue& command,
                           UserRole role,
                           std::string* id,
-                          chromeos::ErrorPtr* error) = 0;
+                          ErrorPtr* error) = 0;
 
   // Finds a command by the command |id|. Returns nullptr if the command with
   // the given |id| is not found. The returned pointer should not be persisted
diff --git a/libweave/include/weave/error.h b/libweave/include/weave/error.h
new file mode 100644
index 0000000..278d2f9
--- /dev/null
+++ b/libweave/include/weave/error.h
@@ -0,0 +1,130 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_INCLUDE_WEAVE_ERROR_H_
+#define LIBWEAVE_INCLUDE_WEAVE_ERROR_H_
+
+#include <memory>
+#include <string>
+
+#include <base/macros.h>
+#include <base/tracked_objects.h>
+#include <weave/export.h>
+
+namespace weave {
+
+class Error;  // Forward declaration.
+
+using ErrorPtr = std::unique_ptr<Error>;
+
+class Error final {
+ public:
+  ~Error() = default;
+
+  // Creates an instance of Error class.
+  static ErrorPtr Create(const tracked_objects::Location& location,
+                         const std::string& domain,
+                         const std::string& code,
+                         const std::string& message);
+  static ErrorPtr Create(const tracked_objects::Location& location,
+                         const std::string& domain,
+                         const std::string& code,
+                         const std::string& message,
+                         ErrorPtr inner_error);
+  // If |error| is not nullptr, creates another instance of Error class,
+  // initializes it with specified arguments and adds it to the head of
+  // the error chain pointed to by |error|.
+  LIBWEAVE_EXPORT static void AddTo(ErrorPtr* error,
+                                    const tracked_objects::Location& location,
+                                    const std::string& domain,
+                                    const std::string& code,
+                                    const std::string& message);
+  // Same as the Error::AddTo above, but allows to pass in a printf-like
+  // format string and optional parameters to format the error message.
+  LIBWEAVE_EXPORT static void AddToPrintf(
+      ErrorPtr* error,
+      const tracked_objects::Location& location,
+      const std::string& domain,
+      const std::string& code,
+      const char* format,
+      ...) PRINTF_FORMAT(5, 6);
+
+  // Clones error with all inner errors.
+  ErrorPtr Clone() const;
+
+  // Returns the error domain, code and message
+  const std::string& GetDomain() const { return domain_; }
+  const std::string& GetCode() const { return code_; }
+  const std::string& GetMessage() const { return message_; }
+
+  // Returns the location of the error in the source code.
+  const tracked_objects::LocationSnapshot& GetLocation() const {
+    return location_;
+  }
+
+  // Checks if this or any of the inner errors in the chain has the specified
+  // error domain.
+  bool HasDomain(const std::string& domain) const;
+
+  // Checks if this or any of the inner errors in the chain matches the
+  // specified error domain and code.
+  bool HasError(const std::string& domain, const std::string& code) const;
+
+  // Gets a pointer to the inner error, if present. Returns nullptr otherwise.
+  const Error* GetInnerError() const { return inner_error_.get(); }
+
+  // Gets a pointer to the first error occurred.
+  // Returns itself if no inner error are available.
+  const Error* GetFirstError() const;
+
+  // Finds an error object of particular domain in the error chain stating at
+  // |error_chain_start|. Returns the a pointer to the first matching error
+  // object found.
+  // Returns nullptr if no match is found.
+  // This method is safe to call on a nullptr |error_chain_start| in which case
+  // the result will also be nullptr.
+  static const Error* FindErrorOfDomain(const Error* error_chain_start,
+                                        const std::string& domain);
+  // Finds an error of particular domain with the given code in the error chain
+  // stating at |error_chain_start|. Returns the pointer to the first matching
+  // error object.
+  // Returns nullptr if no match is found or if |error_chain_start| is nullptr.
+  static const Error* FindError(const Error* error_chain_start,
+                                const std::string& domain,
+                                const std::string& code);
+
+ protected:
+  // Constructor is protected since this object is supposed to be
+  // created via the Create factory methods.
+  Error(const tracked_objects::Location& location,
+        const std::string& domain,
+        const std::string& code,
+        const std::string& message,
+        ErrorPtr inner_error);
+
+  Error(const tracked_objects::LocationSnapshot& location,
+        const std::string& domain,
+        const std::string& code,
+        const std::string& message,
+        ErrorPtr inner_error);
+
+  // Error domain. The domain defines the scopes for error codes.
+  // Two errors with the same code but different domains are different errors.
+  std::string domain_;
+  // Error code. A unique error code identifier within the given domain.
+  std::string code_;
+  // Human-readable error message.
+  std::string message_;
+  // Error origin in the source code.
+  tracked_objects::LocationSnapshot location_;
+  // Pointer to inner error, if any. This forms a chain of errors.
+  ErrorPtr inner_error_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Error);
+};
+
+}  // namespace weave
+
+#endif  // LIBWEAVE_INCLUDE_WEAVE_ERROR_H_
diff --git a/libweave/include/weave/http_client.h b/libweave/include/weave/http_client.h
index 401f1c5..6112271 100644
--- a/libweave/include/weave/http_client.h
+++ b/libweave/include/weave/http_client.h
@@ -10,7 +10,7 @@
 #include <vector>
 
 #include <base/callback.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -28,7 +28,7 @@
 
   using Headers = std::vector<std::pair<std::string, std::string>>;
   using SuccessCallback = base::Callback<void(int, const Response&)>;
-  using ErrorCallback = base::Callback<void(int, const chromeos::Error*)>;
+  using ErrorCallback = base::Callback<void(int, const Error*)>;
 
   // TODO(vitalybuka): Remove blocking version.
   virtual std::unique_ptr<Response> SendRequestAndBlock(
@@ -36,7 +36,7 @@
       const std::string& url,
       const Headers& headers,
       const std::string& data,
-      chromeos::ErrorPtr* error) = 0;
+      ErrorPtr* error) = 0;
 
   virtual int SendRequest(const std::string& method,
                           const std::string& url,
diff --git a/libweave/include/weave/mock_command.h b/libweave/include/weave/mock_command.h
index 1444cd4..7d0c938 100644
--- a/libweave/include/weave/mock_command.h
+++ b/libweave/include/weave/mock_command.h
@@ -30,10 +30,8 @@
   MOCK_CONST_METHOD0(MockGetParameters, const std::string&());
   MOCK_CONST_METHOD0(MockGetProgress, const std::string&());
   MOCK_CONST_METHOD0(MockGetResults, const std::string&());
-  MOCK_METHOD2(SetProgress,
-               bool(const base::DictionaryValue&, chromeos::ErrorPtr*));
-  MOCK_METHOD2(SetResults,
-               bool(const base::DictionaryValue&, chromeos::ErrorPtr*));
+  MOCK_METHOD2(SetProgress, bool(const base::DictionaryValue&, ErrorPtr*));
+  MOCK_METHOD2(SetResults, bool(const base::DictionaryValue&, ErrorPtr*));
   MOCK_METHOD0(Abort, void());
   MOCK_METHOD0(Cancel, void());
   MOCK_METHOD0(Done, void());
diff --git a/libweave/include/weave/mock_commands.h b/libweave/include/weave/mock_commands.h
index 21ae120..7e13cd5 100644
--- a/libweave/include/weave/mock_commands.h
+++ b/libweave/include/weave/mock_commands.h
@@ -20,11 +20,9 @@
 
   MOCK_METHOD1(AddOnCommandAddedCallback, void(const OnCommandCallback&));
   MOCK_METHOD1(AddOnCommandRemovedCallback, void(const OnCommandCallback&));
-  MOCK_METHOD4(AddCommand,
-               bool(const base::DictionaryValue&,
-                    UserRole,
-                    std::string*,
-                    chromeos::ErrorPtr*));
+  MOCK_METHOD4(
+      AddCommand,
+      bool(const base::DictionaryValue&, UserRole, std::string*, ErrorPtr*));
   MOCK_METHOD1(FindCommand, Command*(const std::string&));
 };
 
diff --git a/libweave/include/weave/mock_http_client.h b/libweave/include/weave/mock_http_client.h
index cb1b96e..7ea1f26 100644
--- a/libweave/include/weave/mock_http_client.h
+++ b/libweave/include/weave/mock_http_client.h
@@ -31,14 +31,13 @@
                          const std::string&,
                          const Headers&,
                          const std::string&,
-                         chromeos::ErrorPtr*));
+                         ErrorPtr*));
 
-  std::unique_ptr<Response> SendRequestAndBlock(
-      const std::string& method,
-      const std::string& url,
-      const Headers& headers,
-      const std::string& data,
-      chromeos::ErrorPtr* error) override;
+  std::unique_ptr<Response> SendRequestAndBlock(const std::string& method,
+                                                const std::string& url,
+                                                const Headers& headers,
+                                                const std::string& data,
+                                                ErrorPtr* error) override;
 
   int SendRequest(const std::string& method,
                   const std::string& url,
diff --git a/libweave/include/weave/network.h b/libweave/include/weave/network.h
index d9c56b9..41e5413 100644
--- a/libweave/include/weave/network.h
+++ b/libweave/include/weave/network.h
@@ -9,7 +9,7 @@
 #include <string>
 
 #include <base/callback.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/stream.h>
 
 namespace weave {
@@ -37,7 +37,7 @@
   virtual bool ConnectToService(const std::string& ssid,
                                 const std::string& passphrase,
                                 const base::Closure& on_success,
-                                chromeos::ErrorPtr* error) = 0;
+                                ErrorPtr* error) = 0;
 
   virtual NetworkState GetConnectionState() const = 0;
 
@@ -57,7 +57,7 @@
       std::unique_ptr<Stream> socket,
       const std::string& host,
       const base::Callback<void(std::unique_ptr<Stream>)>& success_callback,
-      const base::Callback<void(const chromeos::Error*)>& error_callback) = 0;
+      const base::Callback<void(const Error*)>& error_callback) = 0;
 
  protected:
   virtual ~Network() = default;
diff --git a/libweave/include/weave/state.h b/libweave/include/weave/state.h
index c817a75..f1f57e6 100644
--- a/libweave/include/weave/state.h
+++ b/libweave/include/weave/state.h
@@ -17,7 +17,7 @@
 
   // Updates a multiple property values.
   virtual bool SetProperties(const base::DictionaryValue& property_set,
-                             chromeos::ErrorPtr* error) = 0;
+                             ErrorPtr* error) = 0;
 
   // Returns aggregated state properties across all registered packages as
   // a JSON object that can be used to send the device state to the GCD server.
diff --git a/libweave/include/weave/stream.h b/libweave/include/weave/stream.h
index 9717d78..3ecdba6 100644
--- a/libweave/include/weave/stream.h
+++ b/libweave/include/weave/stream.h
@@ -8,7 +8,7 @@
 #include <string>
 
 #include <base/callback.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -20,19 +20,19 @@
       void* buffer,
       size_t size_to_read,
       const base::Callback<void(size_t)>& success_callback,
-      const base::Callback<void(const chromeos::Error*)>& error_callback,
-      chromeos::ErrorPtr* error) = 0;
+      const base::Callback<void(const Error*)>& error_callback,
+      ErrorPtr* error) = 0;
 
   virtual bool WriteAllAsync(
       const void* buffer,
       size_t size_to_write,
       const base::Closure& success_callback,
-      const base::Callback<void(const chromeos::Error*)>& error_callback,
-      chromeos::ErrorPtr* error) = 0;
+      const base::Callback<void(const Error*)>& error_callback,
+      ErrorPtr* error) = 0;
 
-  virtual bool FlushBlocking(chromeos::ErrorPtr* error) = 0;
+  virtual bool FlushBlocking(ErrorPtr* error) = 0;
 
-  virtual bool CloseBlocking(chromeos::ErrorPtr* error) = 0;
+  virtual bool CloseBlocking(ErrorPtr* error) = 0;
 
   virtual void CancelPendingAsyncOperations() = 0;
 };
diff --git a/libweave/include/weave/task_runner.h b/libweave/include/weave/task_runner.h
index 2c3057c..0b349b6 100644
--- a/libweave/include/weave/task_runner.h
+++ b/libweave/include/weave/task_runner.h
@@ -10,7 +10,6 @@
 #include <vector>
 
 #include <base/callback.h>
-#include <chromeos/errors/error.h>
 
 namespace weave {
 
diff --git a/libweave/libweave.gyp b/libweave/libweave.gyp
index 3ff064b..649d9f4 100644
--- a/libweave/libweave.gyp
+++ b/libweave/libweave.gyp
@@ -30,6 +30,8 @@
     {
       'target_name': 'libweave_common',
       'type': 'static_library',
+      'cflags!': ['-fPIE'],
+      'cflags': ['-fPIC'],
       'sources': [
         'src/backoff_entry.cc',
         'src/base_api_handler.cc',
@@ -50,6 +52,7 @@
         'src/data_encoding.cc',
         'src/device_manager.cc',
         'src/device_registration_info.cc',
+        'src/error.cc',
         'src/http_constants.cc',
         'src/json_error_codes.cc',
         'src/notification/notification_parser.cc',
@@ -140,6 +143,7 @@
             'src/commands/schema_utils_unittest.cc',
             'src/data_encoding_unittest.cc',
             'src/device_registration_info_unittest.cc',
+            'src/error_unittest.cc',
             'src/notification/notification_parser_unittest.cc',
             'src/notification/xml_node_unittest.cc',
             'src/notification/xmpp_channel_unittest.cc',
diff --git a/libweave/src/buffet_config.h b/libweave/src/buffet_config.h
index 004e8b2..2d161e1 100644
--- a/libweave/src/buffet_config.h
+++ b/libweave/src/buffet_config.h
@@ -11,7 +11,7 @@
 
 #include <base/callback.h>
 #include <base/files/file_path.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <chromeos/key_value_store.h>
 #include <weave/config.h>
 
diff --git a/libweave/src/commands/command_definition.cc b/libweave/src/commands/command_definition.cc
index 66a487c..f00efdd 100644
--- a/libweave/src/commands/command_definition.cc
+++ b/libweave/src/commands/command_definition.cc
@@ -6,7 +6,7 @@
 
 #include <vector>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/schema_constants.h"
 #include "libweave/src/string_utils.h"
@@ -14,7 +14,7 @@
 namespace weave {
 
 bool CommandDefinition::Visibility::FromString(const std::string& str,
-                                               chromeos::ErrorPtr* error) {
+                                               ErrorPtr* error) {
   // This special case is useful for places where we want to make a command
   // to ALL clients, even if new clients are added in the future.
   if (str == commands::attributes::kCommand_Visibility_All) {
@@ -35,10 +35,10 @@
     } else if (value == commands::attributes::kCommand_Visibility_Cloud) {
       cloud = true;
     } else {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidPropValue,
-                                   "Invalid command visibility value '%s'",
-                                   value.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidPropValue,
+                         "Invalid command visibility value '%s'",
+                         value.c_str());
       return false;
     }
   }
diff --git a/libweave/src/commands/command_definition.h b/libweave/src/commands/command_definition.h
index 0ef8fec..512f08d 100644
--- a/libweave/src/commands/command_definition.h
+++ b/libweave/src/commands/command_definition.h
@@ -31,7 +31,7 @@
     // Visibility bitset (|str| is a string like "local,cloud").
     // Special string value "all" is treated as a list of every possible
     // visibility values and "none" to have all the bits cleared.
-    bool FromString(const std::string& str, chromeos::ErrorPtr* error);
+    bool FromString(const std::string& str, ErrorPtr* error);
 
     // Converts the visibility bitset to a string.
     std::string ToString() const;
diff --git a/libweave/src/commands/command_definition_unittest.cc b/libweave/src/commands/command_definition_unittest.cc
index 158d43d..458a84e 100644
--- a/libweave/src/commands/command_definition_unittest.cc
+++ b/libweave/src/commands/command_definition_unittest.cc
@@ -59,7 +59,7 @@
   EXPECT_FALSE(visibility.local);
   EXPECT_FALSE(visibility.cloud);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(visibility.FromString("cloud,all", &error));
   EXPECT_EQ("invalid_parameter_value", error->GetCode());
 }
diff --git a/libweave/src/commands/command_dictionary.cc b/libweave/src/commands/command_dictionary.cc
index 2f36850..c1238dc 100644
--- a/libweave/src/commands/command_dictionary.cc
+++ b/libweave/src/commands/command_dictionary.cc
@@ -26,7 +26,7 @@
 bool CommandDictionary::LoadCommands(const base::DictionaryValue& json,
                                      const std::string& category,
                                      const CommandDictionary* base_commands,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   CommandMap new_defs;
 
   // |json| contains a list of nested objects with the following structure:
@@ -37,10 +37,10 @@
     std::string package_name = package_iter.key();
     const base::DictionaryValue* package_value = nullptr;
     if (!package_iter.value().GetAsDictionary(&package_value)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kTypeMismatch,
-                                   "Expecting an object for package '%s'",
-                                   package_name.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kTypeMismatch,
+                         "Expecting an object for package '%s'",
+                         package_name.c_str());
       return false;
     }
     // Iterate over command definitions within the current package.
@@ -48,19 +48,18 @@
     while (!command_iter.IsAtEnd()) {
       std::string command_name = command_iter.key();
       if (command_name.empty()) {
-        chromeos::Error::AddToPrintf(
-            error, FROM_HERE, errors::commands::kDomain,
-            errors::commands::kInvalidCommandName,
-            "Unnamed command encountered in package '%s'",
-            package_name.c_str());
+        Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                           errors::commands::kInvalidCommandName,
+                           "Unnamed command encountered in package '%s'",
+                           package_name.c_str());
         return false;
       }
       const base::DictionaryValue* command_def_json = nullptr;
       if (!command_iter.value().GetAsDictionary(&command_def_json)) {
-        chromeos::Error::AddToPrintf(
-            error, FROM_HERE, errors::commands::kDomain,
-            errors::commands::kTypeMismatch,
-            "Expecting an object for command '%s'", command_name.c_str());
+        Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                           errors::commands::kTypeMismatch,
+                           "Expecting an object for command '%s'",
+                           command_name.c_str());
         return false;
       }
       // Construct the compound command name as "pkg_name.cmd_name".
@@ -88,12 +87,11 @@
         // this rule here.
         if (!cmd) {
           if (command_name.front() != '_') {
-            chromeos::Error::AddToPrintf(
-                error, FROM_HERE, errors::commands::kDomain,
-                errors::commands::kInvalidCommandName,
-                "The name of custom command '%s' in package '%s'"
-                " must start with '_'",
-                command_name.c_str(), package_name.c_str());
+            Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                               errors::commands::kInvalidCommandName,
+                               "The name of custom command '%s' in package '%s'"
+                               " must start with '_'",
+                               command_name.c_str(), package_name.c_str());
             return false;
           }
         }
@@ -121,10 +119,10 @@
       if (command_def_json->GetString(commands::attributes::kCommand_Visibility,
                                       &value)) {
         if (!visibility.FromString(value, error)) {
-          chromeos::Error::AddToPrintf(
-              error, FROM_HERE, errors::commands::kDomain,
-              errors::commands::kInvalidCommandVisibility,
-              "Error parsing command '%s'", full_command_name.c_str());
+          Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                             errors::commands::kInvalidCommandVisibility,
+                             "Error parsing command '%s'",
+                             full_command_name.c_str());
           return false;
         }
       }
@@ -132,14 +130,13 @@
       if (command_def_json->GetString(commands::attributes::kCommand_Role,
                                       &value)) {
         if (!StringToEnum(value, &minimal_role)) {
-          chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                       errors::commands::kDomain,
-                                       errors::commands::kInvalidPropValue,
-                                       "Invalid role: '%s'", value.c_str());
-          chromeos::Error::AddToPrintf(
-              error, FROM_HERE, errors::commands::kDomain,
-              errors::commands::kInvalidMinimalRole,
-              "Error parsing command '%s'", full_command_name.c_str());
+          Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                             errors::commands::kInvalidPropValue,
+                             "Invalid role: '%s'", value.c_str());
+          Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                             errors::commands::kInvalidMinimalRole,
+                             "Error parsing command '%s'",
+                             full_command_name.c_str());
           return false;
         }
       }
@@ -187,7 +184,7 @@
     const char* property_name,
     const ObjectSchema* base_def,
     const std::string& command_name,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   auto object_schema = ObjectSchema::Create();
 
   const base::DictionaryValue* schema_def = nullptr;
@@ -199,10 +196,10 @@
   }
 
   if (!object_schema->FromJson(schema_def, base_def, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kInvalidObjectSchema,
-                                 "Invalid definition for command '%s'",
-                                 command_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kInvalidObjectSchema,
+                       "Invalid definition for command '%s'",
+                       command_name.c_str());
     return {};
   }
 
@@ -212,7 +209,7 @@
 std::unique_ptr<base::DictionaryValue> CommandDictionary::GetCommandsAsJson(
     const std::function<bool(const CommandDefinition*)>& filter,
     bool full_schema,
-    chromeos::ErrorPtr* error) const {
+    ErrorPtr* error) const {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   for (const auto& pair : definitions_) {
     // Check if the command definition has the desired visibility.
diff --git a/libweave/src/commands/command_dictionary.h b/libweave/src/commands/command_dictionary.h
index 9a3c407..1f18257 100644
--- a/libweave/src/commands/command_dictionary.h
+++ b/libweave/src/commands/command_dictionary.h
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include <base/macros.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/command_definition.h"
 
@@ -56,7 +56,7 @@
   bool LoadCommands(const base::DictionaryValue& json,
                     const std::string& category,
                     const CommandDictionary* base_commands,
-                    chromeos::ErrorPtr* error);
+                    ErrorPtr* error);
   // Converts all the command definitions to a JSON object for CDD/Device
   // draft.
   // |filter| is a predicate used to filter out the command definitions to
@@ -69,7 +69,7 @@
   std::unique_ptr<base::DictionaryValue> GetCommandsAsJson(
       const std::function<bool(const CommandDefinition*)>& filter,
       bool full_schema,
-      chromeos::ErrorPtr* error) const;
+      ErrorPtr* error) const;
   // Returns the number of command definitions in the dictionary.
   size_t GetSize() const { return definitions_.size(); }
   // Checks if the dictionary has no command definitions.
@@ -88,7 +88,7 @@
       const char* property_name,
       const ObjectSchema* base_def,
       const std::string& command_name,
-      chromeos::ErrorPtr* error);
+      ErrorPtr* error);
 
   CommandMap definitions_;  // List of all available command definitions.
   DISALLOW_COPY_AND_ASSIGN(CommandDictionary);
diff --git a/libweave/src/commands/command_dictionary_unittest.cc b/libweave/src/commands/command_dictionary_unittest.cc
index 7dd3526..17c0af2 100644
--- a/libweave/src/commands/command_dictionary_unittest.cc
+++ b/libweave/src/commands/command_dictionary_unittest.cc
@@ -101,7 +101,7 @@
 
 TEST(CommandDictionary, LoadCommands_Failures) {
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   // Command definition is not an object.
   auto json = CreateDictionaryValue("{'robot':{'jump':0}}");
@@ -133,7 +133,7 @@
 TEST(CommandDictionaryDeathTest, LoadCommands_RedefineInDifferentCategory) {
   // Redefine commands in different category.
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto json = CreateDictionaryValue("{'robot':{'jump':{}}}");
   dict.LoadCommands(*json, "category1", nullptr, &error);
   ASSERT_DEATH(dict.LoadCommands(*json, "category2", nullptr, &error),
@@ -145,7 +145,7 @@
   // Custom command must start with '_'.
   CommandDictionary base_dict;
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto json = CreateDictionaryValue(R"({
     'base': {
       'reboot': {
@@ -172,7 +172,7 @@
   // Redefine commands parameter type.
   CommandDictionary base_dict;
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto json = CreateDictionaryValue(R"({
     'base': {
       'reboot': {
@@ -527,7 +527,7 @@
 
 TEST(CommandDictionary, LoadWithPermissions_InvalidVisibility) {
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   auto json = CreateDictionaryValue(R"({
     'base': {
@@ -546,7 +546,7 @@
 
 TEST(CommandDictionary, LoadWithPermissions_InvalidRole) {
   CommandDictionary dict;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   auto json = CreateDictionaryValue(R"({
     'base': {
diff --git a/libweave/src/commands/command_instance.cc b/libweave/src/commands/command_instance.cc
index de0fdd5..774589f 100644
--- a/libweave/src/commands/command_instance.cc
+++ b/libweave/src/commands/command_instance.cc
@@ -5,8 +5,8 @@
 #include "libweave/src/commands/command_instance.h"
 
 #include <base/values.h>
-#include <chromeos/errors/error.h>
 #include <weave/enum_to_string.h>
+#include <weave/error.h>
 #include <weave/export.h>
 
 #include "libweave/src/commands/command_definition.h"
@@ -95,7 +95,7 @@
 }
 
 bool CommandInstance::SetProgress(const base::DictionaryValue& progress,
-                                  chromeos::ErrorPtr* error) {
+                                  ErrorPtr* error) {
   ObjectPropType obj_prop_type;
   obj_prop_type.SetObjectSchema(command_definition_->GetProgress()->Clone());
 
@@ -113,7 +113,7 @@
 }
 
 bool CommandInstance::SetResults(const base::DictionaryValue& results,
-                                 chromeos::ErrorPtr* error) {
+                                 ErrorPtr* error) {
   ObjectPropType obj_prop_type;
   obj_prop_type.SetObjectSchema(command_definition_->GetResults()->Clone());
 
@@ -139,7 +139,7 @@
 bool GetCommandParameters(const base::DictionaryValue* json,
                           const CommandDefinition* command_def,
                           ValueMap* parameters,
-                          chromeos::ErrorPtr* error) {
+                          ErrorPtr* error) {
   // Get the command parameters from 'parameters' property.
   base::DictionaryValue no_params;  // Placeholder when no params are specified.
   const base::DictionaryValue* params = nullptr;
@@ -147,10 +147,10 @@
   if (json->Get(commands::attributes::kCommand_Parameters, &params_value)) {
     // Make sure the "parameters" property is actually an object.
     if (!params_value->GetAsDictionary(&params)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                   errors::json::kObjectExpected,
-                                   "Property '%s' must be a JSON object",
-                                   commands::attributes::kCommand_Parameters);
+      Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                         errors::json::kObjectExpected,
+                         "Property '%s' must be a JSON object",
+                         commands::attributes::kCommand_Parameters);
       return false;
     }
   } else {
@@ -175,7 +175,7 @@
     CommandOrigin origin,
     const CommandDictionary& dictionary,
     std::string* command_id,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   std::unique_ptr<CommandInstance> instance;
   std::string command_id_buffer;  // used if |command_id| was nullptr.
   if (!command_id)
@@ -184,9 +184,9 @@
   // Get the command JSON object from the value.
   const base::DictionaryValue* json = nullptr;
   if (!value->GetAsDictionary(&json)) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::json::kDomain,
-                           errors::json::kObjectExpected,
-                           "Command instance is not a JSON object");
+    Error::AddTo(error, FROM_HERE, errors::json::kDomain,
+                 errors::json::kObjectExpected,
+                 "Command instance is not a JSON object");
     command_id->clear();
     return instance;
   }
@@ -198,27 +198,24 @@
   // Get the command name from 'name' property.
   std::string command_name;
   if (!json->GetString(commands::attributes::kCommand_Name, &command_name)) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                           errors::commands::kPropertyMissing,
-                           "Command name is missing");
+    Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+                 errors::commands::kPropertyMissing, "Command name is missing");
     return instance;
   }
   // Make sure we know how to handle the command with this name.
   auto command_def = dictionary.FindCommand(command_name);
   if (!command_def) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kInvalidCommandName,
-                                 "Unknown command received: %s",
-                                 command_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kInvalidCommandName,
+                       "Unknown command received: %s", command_name.c_str());
     return instance;
   }
 
   ValueMap parameters;
   if (!GetCommandParameters(json, command_def, &parameters, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kCommandFailed,
-                                 "Failed to validate command '%s'",
-                                 command_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kCommandFailed,
+                       "Failed to validate command '%s'", command_name.c_str());
     return instance;
   }
 
diff --git a/libweave/src/commands/command_instance.h b/libweave/src/commands/command_instance.h
index 65726ac..3f81893 100644
--- a/libweave/src/commands/command_instance.h
+++ b/libweave/src/commands/command_instance.h
@@ -12,7 +12,7 @@
 
 #include <base/macros.h>
 #include <base/observer_list.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/command.h>
 
 #include "libweave/src/commands/prop_values.h"
@@ -53,9 +53,9 @@
   std::unique_ptr<base::DictionaryValue> GetProgress() const override;
   std::unique_ptr<base::DictionaryValue> GetResults() const override;
   bool SetProgress(const base::DictionaryValue& progress,
-                   chromeos::ErrorPtr* error) override;
+                   ErrorPtr* error) override;
   bool SetResults(const base::DictionaryValue& results,
-                  chromeos::ErrorPtr* error) override;
+                  ErrorPtr* error) override;
   void Abort() override;
   void Cancel() override;
   void Done() override;
@@ -78,7 +78,7 @@
       CommandOrigin origin,
       const CommandDictionary& dictionary,
       std::string* command_id,
-      chromeos::ErrorPtr* error);
+      ErrorPtr* error);
 
   // Sets the command ID (normally done by CommandQueue when the command
   // instance is added to it).
diff --git a/libweave/src/commands/command_instance_unittest.cc b/libweave/src/commands/command_instance_unittest.cc
index cc1759b..2c2fe45 100644
--- a/libweave/src/commands/command_instance_unittest.cc
+++ b/libweave/src/commands/command_instance_unittest.cc
@@ -138,7 +138,7 @@
 
 TEST_F(CommandInstanceTest, FromJson_NotObject) {
   auto json = CreateValue("'string'");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, &error);
   EXPECT_EQ(nullptr, instance.get());
@@ -147,7 +147,7 @@
 
 TEST_F(CommandInstanceTest, FromJson_NameMissing) {
   auto json = CreateDictionaryValue("{'param': 'value'}");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, &error);
   EXPECT_EQ(nullptr, instance.get());
@@ -156,7 +156,7 @@
 
 TEST_F(CommandInstanceTest, FromJson_UnknownCommand) {
   auto json = CreateDictionaryValue("{'name': 'robot.scream'}");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, &error);
   EXPECT_EQ(nullptr, instance.get());
@@ -168,7 +168,7 @@
     'name': 'robot.speak',
     'parameters': 'hello'
   })");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, &error);
   EXPECT_EQ(nullptr, instance.get());
@@ -185,7 +185,7 @@
       'volume': 20
     }
   })");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, &error);
   EXPECT_EQ(nullptr, instance.get());
diff --git a/libweave/src/commands/command_manager.cc b/libweave/src/commands/command_manager.cc
index 3d28dec..34b10e6 100644
--- a/libweave/src/commands/command_manager.cc
+++ b/libweave/src/commands/command_manager.cc
@@ -6,8 +6,8 @@
 
 #include <base/files/file_enumerator.h>
 #include <base/values.h>
-#include <chromeos/errors/error.h>
 #include <weave/enum_to_string.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/schema_constants.h"
 #include "libweave/src/utils.h"
@@ -28,12 +28,12 @@
 }
 
 bool CommandManager::LoadBaseCommands(const base::DictionaryValue& json,
-                                      chromeos::ErrorPtr* error) {
+                                      ErrorPtr* error) {
   return base_dictionary_.LoadCommands(json, "", nullptr, error);
 }
 
 bool CommandManager::LoadBaseCommands(const base::FilePath& json_file_path,
-                                      chromeos::ErrorPtr* error) {
+                                      ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> json =
       LoadJsonDict(json_file_path, error);
   if (!json)
@@ -43,7 +43,7 @@
 
 bool CommandManager::LoadCommands(const base::DictionaryValue& json,
                                   const std::string& category,
-                                  chromeos::ErrorPtr* error) {
+                                  ErrorPtr* error) {
   bool result =
       dictionary_.LoadCommands(json, category, &base_dictionary_, error);
   for (const auto& cb : on_command_changed_)
@@ -52,7 +52,7 @@
 }
 
 bool CommandManager::LoadCommands(const base::FilePath& json_file_path,
-                                  chromeos::ErrorPtr* error) {
+                                  ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> json =
       LoadJsonDict(json_file_path, error);
   if (!json)
@@ -96,7 +96,7 @@
 bool CommandManager::AddCommand(const base::DictionaryValue& command,
                                 UserRole role,
                                 std::string* id,
-                                chromeos::ErrorPtr* error) {
+                                ErrorPtr* error) {
   auto command_instance = CommandInstance::FromJson(
       &command, CommandOrigin::kLocal, GetCommandDictionary(), nullptr, error);
   if (!command_instance)
@@ -105,7 +105,7 @@
   UserRole minimal_role =
       command_instance->GetCommandDefinition()->GetMinimalRole();
   if (role < minimal_role) {
-    chromeos::Error::AddToPrintf(
+    Error::AddToPrintf(
         error, FROM_HERE, errors::commands::kDomain, "access_denied",
         "User role '%s' less than minimal: '%s'", EnumToString(role).c_str(),
         EnumToString(minimal_role).c_str());
@@ -125,7 +125,7 @@
 bool CommandManager::SetCommandVisibility(
     const std::vector<std::string>& command_names,
     CommandDefinition::Visibility visibility,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   if (command_names.empty())
     return true;
 
@@ -136,9 +136,9 @@
   for (const std::string& name : command_names) {
     CommandDefinition* def = dictionary_.FindCommand(name);
     if (!def) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidCommandName,
-                                   "Command '%s' is unknown", name.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidCommandName,
+                         "Command '%s' is unknown", name.c_str());
       return false;
     }
     definitions.push_back(def);
diff --git a/libweave/src/commands/command_manager.h b/libweave/src/commands/command_manager.h
index d49373f..f42e293 100644
--- a/libweave/src/commands/command_manager.h
+++ b/libweave/src/commands/command_manager.h
@@ -35,7 +35,7 @@
   bool AddCommand(const base::DictionaryValue& command,
                   UserRole role,
                   std::string* id,
-                  chromeos::ErrorPtr* error) override;
+                  ErrorPtr* error) override;
   CommandInstance* FindCommand(const std::string& id) override;
   void AddOnCommandAddedCallback(const OnCommandCallback& callback) override;
   void AddOnCommandRemovedCallback(const OnCommandCallback& callback) override;
@@ -53,27 +53,24 @@
   // device kinds.
   // On success, returns true. Otherwise, |error| contains additional
   // error information.
-  bool LoadBaseCommands(const base::DictionaryValue& json,
-                        chromeos::ErrorPtr* error);
+  bool LoadBaseCommands(const base::DictionaryValue& json, ErrorPtr* error);
 
   // Same as the overload above, but takes a path to a json file to read
   // the base command definitions from.
-  bool LoadBaseCommands(const base::FilePath& json_file_path,
-                        chromeos::ErrorPtr* error);
+  bool LoadBaseCommands(const base::FilePath& json_file_path, ErrorPtr* error);
 
   // Loads device command schema for particular category.
   // See CommandDictionary::LoadCommands for detailed description of the
   // parameters.
   bool LoadCommands(const base::DictionaryValue& json,
                     const std::string& category,
-                    chromeos::ErrorPtr* error);
+                    ErrorPtr* error);
 
   // Same as the overload above, but takes a path to a json file to read
   // the base command definitions from. Also, the command category is
   // derived from file name (without extension). So, if the path points to
   // "power_manager.json", the command category used will be "power_manager".
-  bool LoadCommands(const base::FilePath& json_file_path,
-                    chromeos::ErrorPtr* error);
+  bool LoadCommands(const base::FilePath& json_file_path, ErrorPtr* error);
 
   // Startup method to be called by buffet daemon at startup.
   // Initializes the object and reads files in |definitions_path| to load
@@ -90,7 +87,7 @@
   // Changes the visibility of commands.
   bool SetCommandVisibility(const std::vector<std::string>& command_names,
                             CommandDefinition::Visibility visibility,
-                            chromeos::ErrorPtr* error);
+                            ErrorPtr* error);
 
  private:
   CommandDictionary base_dictionary_;  // Base/std command definitions/schemas.
diff --git a/libweave/src/commands/command_manager_unittest.cc b/libweave/src/commands/command_manager_unittest.cc
index 5413c30..8d79db2 100644
--- a/libweave/src/commands/command_manager_unittest.cc
+++ b/libweave/src/commands/command_manager_unittest.cc
@@ -193,7 +193,7 @@
   EXPECT_EQ("all", dict.FindCommand("foo._bar")->GetVisibility().ToString());
   EXPECT_EQ("none", dict.FindCommand("bar._quux")->GetVisibility().ToString());
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(manager.SetCommandVisibility(
       {"foo._baz", "foo._bar", "test.cmd"},
       CommandDefinition::Visibility::GetLocal(), &error));
diff --git a/libweave/src/commands/object_schema.cc b/libweave/src/commands/object_schema.cc
index b2c6307..3d697ed 100644
--- a/libweave/src/commands/object_schema.cc
+++ b/libweave/src/commands/object_schema.cc
@@ -23,7 +23,7 @@
 // Helper function for to create a PropType based on type string.
 // Generates an error if the string identifies an unknown type.
 std::unique_ptr<PropType> CreatePropType(const std::string& type_name,
-                                         chromeos::ErrorPtr* error) {
+                                         ErrorPtr* error) {
   auto parts = SplitAtFirst(type_name, ".", false);
   const std::string& primary_type = parts.first;
   const std::string& array_type = parts.second;
@@ -43,18 +43,18 @@
     }
   }
   if (!prop) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kUnknownType,
-                                 "Unknown type %s", type_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kUnknownType, "Unknown type %s",
+                       type_name.c_str());
   }
   return prop;
 }
 
 // Generates "no_type_info" error.
-void ErrorInvalidTypeInfo(chromeos::ErrorPtr* error) {
-  chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                         errors::commands::kNoTypeInfo,
-                         "Unable to determine parameter type");
+void ErrorInvalidTypeInfo(ErrorPtr* error) {
+  Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+               errors::commands::kNoTypeInfo,
+               "Unable to determine parameter type");
 }
 
 // Helper function for PropFromJson to handle the case of parameter being
@@ -62,7 +62,7 @@
 //   "prop":"..."
 std::unique_ptr<PropType> PropFromJsonString(const base::Value& value,
                                              const PropType* base_schema,
-                                             chromeos::ErrorPtr* error) {
+                                             ErrorPtr* error) {
   std::string type_name;
   CHECK(value.GetAsString(&type_name)) << "Unable to get string value";
   std::unique_ptr<PropType> prop = CreatePropType(type_name, error);
@@ -132,7 +132,7 @@
 //   "prop":[...]
 std::unique_ptr<PropType> PropFromJsonArray(const base::Value& value,
                                             const PropType* base_schema,
-                                            chromeos::ErrorPtr* error) {
+                                            ErrorPtr* error) {
   std::unique_ptr<PropType> prop;
   const base::ListValue* list = nullptr;
   CHECK(value.GetAsList(&list)) << "Unable to get array value";
@@ -234,7 +234,7 @@
 //   "prop":{...}
 std::unique_ptr<PropType> PropFromJsonObject(const base::Value& value,
                                              const PropType* base_schema,
-                                             chromeos::ErrorPtr* error) {
+                                             ErrorPtr* error) {
   std::unique_ptr<PropType> prop;
   const base::DictionaryValue* dict = nullptr;
   CHECK(value.GetAsDictionary(&dict)) << "Unable to get dictionary value";
@@ -303,13 +303,12 @@
   return p != properties_.end() ? p->second.get() : nullptr;
 }
 
-bool ObjectSchema::MarkPropRequired(const std::string& name,
-                                    chromeos::ErrorPtr* error) {
+bool ObjectSchema::MarkPropRequired(const std::string& name, ErrorPtr* error) {
   auto p = properties_.find(name);
   if (p == properties_.end()) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                  errors::commands::kUnknownProperty,
-                                  "Unknown property '%s'", name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kUnknownProperty,
+                       "Unknown property '%s'", name.c_str());
     return false;
   }
   p->second->MakeRequired(true);
@@ -330,7 +329,7 @@
 
 bool ObjectSchema::FromJson(const base::DictionaryValue* value,
                             const ObjectSchema* object_schema,
-                            chromeos::ErrorPtr* error) {
+                            ErrorPtr* error) {
   Properties properties;
   base::DictionaryValue::Iterator iter(*value);
   while (!iter.IsAtEnd()) {
@@ -341,10 +340,10 @@
     if (prop_type) {
       properties.emplace(iter.key(), std::move(prop_type));
     } else {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidPropDef,
-                                   "Error in definition of property '%s'",
-                                   iter.key().c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidPropDef,
+                         "Error in definition of property '%s'",
+                         iter.key().c_str());
       return false;
     }
     iter.Advance();
@@ -356,7 +355,7 @@
 std::unique_ptr<PropType> ObjectSchema::PropFromJson(
     const base::Value& value,
     const PropType* base_schema,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   if (value.IsType(base::Value::TYPE_STRING)) {
     // A string value is a short-hand object specification and provides
     // the parameter type.
@@ -368,10 +367,10 @@
     // Full parameter definition.
     return PropFromJsonObject(value, base_schema, error);
   }
-  chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                               errors::commands::kUnknownType,
-                               "Unexpected JSON value type: %s",
-                               EnumToString(value.GetType()).c_str());
+  Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                     errors::commands::kUnknownType,
+                     "Unexpected JSON value type: %s",
+                     EnumToString(value.GetType()).c_str());
   return nullptr;
 }
 
diff --git a/libweave/src/commands/object_schema.h b/libweave/src/commands/object_schema.h
index b971dd8..c65d21e 100644
--- a/libweave/src/commands/object_schema.h
+++ b/libweave/src/commands/object_schema.h
@@ -9,7 +9,7 @@
 #include <memory>
 #include <string>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace base {
 class Value;
@@ -52,7 +52,7 @@
   // Marks the property with given name as "required". If |name| specifies
   // an unknown property, false is returned and |error| is set with detailed
   // error message for the failure.
-  bool MarkPropRequired(const std::string& name, chromeos::ErrorPtr* error);
+  bool MarkPropRequired(const std::string& name, ErrorPtr* error);
 
   // Specify whether extra properties are allowed on objects described by
   // this schema. When validating a value of an object type, we can
@@ -74,7 +74,7 @@
   // used as a base schema to inherit omitted properties and constraints from.
   bool FromJson(const base::DictionaryValue* value,
                 const ObjectSchema* object_schema,
-                chromeos::ErrorPtr* error);
+                ErrorPtr* error);
 
   // Helper factory method to create a new instance of ObjectSchema object.
   static std::unique_ptr<ObjectSchema> Create();
@@ -82,7 +82,7 @@
   // Helper method to load property type definitions from JSON.
   static std::unique_ptr<PropType> PropFromJson(const base::Value& value,
                                                 const PropType* base_schema,
-                                                chromeos::ErrorPtr* error);
+                                                ErrorPtr* error);
 
  private:
   // Internal parameter type definition map.
diff --git a/libweave/src/commands/object_schema_unittest.cc b/libweave/src/commands/object_schema_unittest.cc
index fc04dd5..c7c448a 100644
--- a/libweave/src/commands/object_schema_unittest.cc
+++ b/libweave/src/commands/object_schema_unittest.cc
@@ -49,7 +49,7 @@
 
 bool ValidateValue(const PropType& type,
                    const base::Value& value,
-                   chromeos::ErrorPtr* error) {
+                   ErrorPtr* error) {
   std::unique_ptr<PropValue> val = type.CreatePropValue(value, error);
   return val != nullptr;
 }
@@ -129,7 +129,7 @@
 TEST(CommandSchema, IntPropType_Validate) {
   IntPropType prop;
   prop.AddMinMaxConstraint(2, 4);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(ValidateValue(prop, *CreateValue("-1"), &error));
   EXPECT_EQ("out_of_range", error->GetCode());
   error.reset();
@@ -160,7 +160,7 @@
 
 TEST(CommandSchema, IntPropType_CreateValue) {
   IntPropType prop;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto val = prop.CreateValue(base::FundamentalValue{2}, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
@@ -231,7 +231,7 @@
 TEST(CommandSchema, BoolPropType_Validate) {
   BooleanPropType prop;
   prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop, nullptr);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(ValidateValue(prop, *CreateValue("false"), &error));
   EXPECT_EQ("out_of_range", error->GetCode());
   error.reset();
@@ -249,7 +249,7 @@
 
 TEST(CommandSchema, BoolPropType_CreateValue) {
   BooleanPropType prop;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto val = prop.CreateValue(base::FundamentalValue{true}, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
@@ -341,7 +341,7 @@
 TEST(CommandSchema, DoublePropType_Validate) {
   DoublePropType prop;
   prop.AddMinMaxConstraint(-1.2, 1.3);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(ValidateValue(prop, *CreateValue("-2"), &error));
   EXPECT_EQ("out_of_range", error->GetCode());
   error.reset();
@@ -366,7 +366,7 @@
 
 TEST(CommandSchema, DoublePropType_CreateValue) {
   DoublePropType prop;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto val = prop.CreateValue(base::FundamentalValue{2.0}, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
@@ -460,7 +460,7 @@
 TEST(CommandSchema, StringPropType_Validate) {
   StringPropType prop;
   prop.AddLengthConstraint(1, 3);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(ValidateValue(prop, *CreateValue("''"), &error));
   EXPECT_EQ("out_of_range", error->GetCode());
   error.reset();
@@ -491,7 +491,7 @@
 
 TEST(CommandSchema, StringPropType_CreateValue) {
   StringPropType prop;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto val = prop.CreateValue(base::StringValue{"blah"}, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
@@ -682,7 +682,7 @@
                     "'password':{'maxLength':100,'minLength':6}},"
                     "'required':['expires','password']}").get(),
                 nullptr, nullptr);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_TRUE(ValidateValue(
       prop, *CreateValue("{'expires':10,'password':'abcdef'}"), &error));
   error.reset();
@@ -720,7 +720,7 @@
           "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}")
           .get(),
       nullptr, nullptr));
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_TRUE(
       ValidateValue(prop, *CreateValue("{'height':20,'width':10}"), &error));
   error.reset();
@@ -749,7 +749,7 @@
       {"height", int_type.CreateValue(base::FundamentalValue{20}, nullptr)},
   };
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto val = prop.CreateValue(
       *CreateDictionaryValue("{'width': 10, 'height': 20}"), &error);
   ASSERT_NE(nullptr, val.get());
@@ -831,7 +831,7 @@
       CreateDictionaryValue("{'items':{'minimum':2.3, 'maximum':10.5}}").get(),
       nullptr, nullptr);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_TRUE(ValidateValue(prop, *CreateValue("[3,4,10.5]"), &error));
   error.reset();
 
@@ -851,7 +851,7 @@
           .get(),
       nullptr, nullptr);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_TRUE(ValidateValue(prop, *CreateValue("[2,3]"), &error));
   error.reset();
 
@@ -872,7 +872,7 @@
           .get(),
       nullptr, nullptr));
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ValueVector arr;
 
   auto val = prop.CreateValue(base::ListValue{}, &error);
@@ -897,7 +897,7 @@
 
 TEST(CommandSchema, ArrayPropType_NestedArrays_NotSupported) {
   ArrayPropType prop;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(prop.FromJson(
       CreateDictionaryValue("{'items':{'items':'integer'}}").get(), nullptr,
       &error));
@@ -1334,7 +1334,7 @@
 
 TEST(CommandSchema, ObjectSchema_FromJson_BaseSchema_Failures) {
   ObjectSchema schema;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   const char* schema_str =
       "{"
       "'param1':{}"
@@ -1605,7 +1605,7 @@
 
 TEST(CommandSchema, RequiredProperties_Failures) {
   ObjectPropType obj_type;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   auto type_str = R"({
     'properties': {
@@ -1688,7 +1688,7 @@
                             nullptr));
 
   auto val_json = "{'param2':20}";
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto value =
       prop.CreatePropValue(*CreateDictionaryValue(val_json).get(), &error);
   ASSERT_EQ(nullptr, value);
diff --git a/libweave/src/commands/prop_constraints.cc b/libweave/src/commands/prop_constraints.cc
index 0b77ec5..c1ab1c4 100644
--- a/libweave/src/commands/prop_constraints.cc
+++ b/libweave/src/commands/prop_constraints.cc
@@ -30,35 +30,33 @@
 Constraint::~Constraint() {
 }
 
-bool Constraint::ReportErrorLessThan(chromeos::ErrorPtr* error,
+bool Constraint::ReportErrorLessThan(ErrorPtr* error,
                                      const std::string& val,
                                      const std::string& limit) {
-  chromeos::Error::AddToPrintf(
-      error, FROM_HERE, errors::commands::kDomain,
-      errors::commands::kOutOfRange,
-      "Value %s is out of range. It must not be less than %s", val.c_str(),
-      limit.c_str());
+  Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                     errors::commands::kOutOfRange,
+                     "Value %s is out of range. It must not be less than %s",
+                     val.c_str(), limit.c_str());
   return false;
 }
 
-bool Constraint::ReportErrorGreaterThan(chromeos::ErrorPtr* error,
+bool Constraint::ReportErrorGreaterThan(ErrorPtr* error,
                                         const std::string& val,
                                         const std::string& limit) {
-  chromeos::Error::AddToPrintf(
-      error, FROM_HERE, errors::commands::kDomain,
-      errors::commands::kOutOfRange,
-      "Value %s is out of range. It must not be greater than %s", val.c_str(),
-      limit.c_str());
+  Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                     errors::commands::kOutOfRange,
+                     "Value %s is out of range. It must not be greater than %s",
+                     val.c_str(), limit.c_str());
   return false;
 }
 
-bool Constraint::ReportErrorNotOneOf(chromeos::ErrorPtr* error,
+bool Constraint::ReportErrorNotOneOf(ErrorPtr* error,
                                      const std::string& val,
                                      const std::vector<std::string>& values) {
-  chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                               errors::commands::kOutOfRange,
-                               "Value %s is invalid. Expected one of [%s]",
-                               val.c_str(), Join(",", values).c_str());
+  Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                     errors::commands::kOutOfRange,
+                     "Value %s is invalid. Expected one of [%s]", val.c_str(),
+                     Join(",", values).c_str());
   return false;
 }
 
@@ -97,21 +95,20 @@
 }
 
 bool ConstraintStringLengthMin::Validate(const PropValue& value,
-                                         chromeos::ErrorPtr* error) const {
+                                         ErrorPtr* error) const {
   CHECK(value.GetString()) << "Expecting a string value for this constraint";
   const std::string& str = value.GetString()->GetValue();
   int length = static_cast<int>(str.size());
   if (length < limit_.value) {
     if (limit_.value == 1) {
-      chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                             errors::commands::kOutOfRange,
-                             "String must not be empty");
+      Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+                   errors::commands::kOutOfRange, "String must not be empty");
     } else {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kOutOfRange,
-                                   "String must be at least %d characters long,"
-                                   " actual length of string '%s' is %d",
-                                   limit_.value, str.c_str(), length);
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kOutOfRange,
+                         "String must be at least %d characters long,"
+                         " actual length of string '%s' is %d",
+                         limit_.value, str.c_str(), length);
     }
     return false;
   }
@@ -138,16 +135,16 @@
 }
 
 bool ConstraintStringLengthMax::Validate(const PropValue& value,
-                                         chromeos::ErrorPtr* error) const {
+                                         ErrorPtr* error) const {
   CHECK(value.GetString()) << "Expecting a string value for this constraint";
   const std::string& str = value.GetString()->GetValue();
   int length = static_cast<int>(str.size());
   if (length > limit_.value) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kOutOfRange,
-                                 "String must be no more than %d character(s) "
-                                 "long, actual length of string '%s' is %d",
-                                 limit_.value, str.c_str(), length);
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kOutOfRange,
+                       "String must be no more than %d character(s) "
+                       "long, actual length of string '%s' is %d",
+                       limit_.value, str.c_str(), length);
     return false;
   }
   return true;
@@ -168,8 +165,7 @@
     : set_(std::move(set)) {}
 ConstraintOneOf::ConstraintOneOf(ValueVector set) : set_(std::move(set)) {}
 
-bool ConstraintOneOf::Validate(const PropValue& value,
-                               chromeos::ErrorPtr* error) const {
+bool ConstraintOneOf::Validate(const PropValue& value, ErrorPtr* error) const {
   for (const auto& item : set_.value) {
     if (value.IsEqual(item.get()))
       return true;
diff --git a/libweave/src/commands/prop_constraints.h b/libweave/src/commands/prop_constraints.h
index c0744d5..be06f6f 100644
--- a/libweave/src/commands/prop_constraints.h
+++ b/libweave/src/commands/prop_constraints.h
@@ -11,7 +11,7 @@
 
 #include <base/macros.h>
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/prop_values.h"
 #include "libweave/src/commands/schema_constants.h"
@@ -42,8 +42,7 @@
   // Validates a parameter against the constraint. Returns true if parameter
   // value satisfies the constraint, otherwise fills the optional |error| with
   // the details for the failure.
-  virtual bool Validate(const PropValue& value,
-                        chromeos::ErrorPtr* error) const = 0;
+  virtual bool Validate(const PropValue& value, ErrorPtr* error) const = 0;
 
   // Makes a full copy of this Constraint instance.
   virtual std::unique_ptr<Constraint> Clone() const = 0;
@@ -77,14 +76,14 @@
   // Since these functions could be used by constraint objects for various
   // data types, the values used in validation are expected to be
   // send as strings already.
-  static bool ReportErrorLessThan(chromeos::ErrorPtr* error,
+  static bool ReportErrorLessThan(ErrorPtr* error,
                                   const std::string& val,
                                   const std::string& limit);
-  static bool ReportErrorGreaterThan(chromeos::ErrorPtr* error,
+  static bool ReportErrorGreaterThan(ErrorPtr* error,
                                      const std::string& val,
                                      const std::string& limit);
 
-  static bool ReportErrorNotOneOf(chromeos::ErrorPtr* error,
+  static bool ReportErrorNotOneOf(ErrorPtr* error,
                                   const std::string& val,
                                   const std::vector<std::string>& values);
 
@@ -130,8 +129,7 @@
   ConstraintType GetType() const override { return ConstraintType::Min; }
 
   // Implementation of Constraint::Validate().
-  bool Validate(const PropValue& value,
-                chromeos::ErrorPtr* error) const override {
+  bool Validate(const PropValue& value, ErrorPtr* error) const override {
     const T& v = static_cast<const TypedValueBase<T>&>(value).GetValue();
     if (v < this->limit_.value) {
       return this->ReportErrorLessThan(error, std::to_string(v),
@@ -171,8 +169,7 @@
   ConstraintType GetType() const override { return ConstraintType::Max; }
 
   // Implementation of Constraint::Validate().
-  bool Validate(const PropValue& value,
-                chromeos::ErrorPtr* error) const override {
+  bool Validate(const PropValue& value, ErrorPtr* error) const override {
     const T& v = static_cast<const TypedValueBase<T>&>(value).GetValue();
     if (v > this->limit_.value)
       return this->ReportErrorGreaterThan(error, std::to_string(v),
@@ -232,8 +229,7 @@
   }
 
   // Implementation of Constraint::Validate().
-  bool Validate(const PropValue& value,
-                chromeos::ErrorPtr* error) const override;
+  bool Validate(const PropValue& value, ErrorPtr* error) const override;
 
   // Implementation of Constraint::Clone().
   std::unique_ptr<Constraint> Clone() const override;
@@ -261,8 +257,7 @@
   }
 
   // Implementation of Constraint::Validate().
-  bool Validate(const PropValue& value,
-                chromeos::ErrorPtr* error) const override;
+  bool Validate(const PropValue& value, ErrorPtr* error) const override;
 
   // Implementation of Constraint::Clone().
   std::unique_ptr<Constraint> Clone() const override;
@@ -292,8 +287,7 @@
   bool HasOverriddenAttributes() const override { return !set_.is_inherited; }
 
   // Implementation of Constraint::Validate().
-  bool Validate(const PropValue& value,
-                chromeos::ErrorPtr* error) const override;
+  bool Validate(const PropValue& value, ErrorPtr* error) const override;
 
   // Implementation of Constraint::Clone().
   std::unique_ptr<Constraint> Clone() const override;
diff --git a/libweave/src/commands/prop_types.cc b/libweave/src/commands/prop_types.cc
index 5a77610..d946675 100644
--- a/libweave/src/commands/prop_types.cc
+++ b/libweave/src/commands/prop_types.cc
@@ -123,13 +123,13 @@
 
 bool PropType::FromJson(const base::DictionaryValue* value,
                         const PropType* base_schema,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   if (base_schema && base_schema->GetType() != GetType()) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kPropTypeChanged,
-                                 "Redefining a property of type %s as %s",
-                                 base_schema->GetTypeAsString().c_str(),
-                                 GetTypeAsString().c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kPropTypeChanged,
+                       "Redefining a property of type %s as %s",
+                       base_schema->GetTypeAsString().c_str(),
+                       GetTypeAsString().c_str());
     return false;
   }
   based_on_schema_ = (base_schema != nullptr);
@@ -159,9 +159,9 @@
   while (!iter.IsAtEnd()) {
     std::string key = iter.key();
     if (processed_keys.find(key) == processed_keys.end()) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kUnknownProperty,
-                                   "Unexpected property '%s'", key.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kUnknownProperty,
+                         "Unexpected property '%s'", key.c_str());
       return false;
     }
     iter.Advance();
@@ -186,10 +186,10 @@
   if (value->GetWithoutPathExpansion(commands::attributes::kDefault, &defval)) {
     std::unique_ptr<PropValue> prop_value = CreatePropValue(*defval, error);
     if (!prop_value) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidPropValue,
-                                   "Invalid value for property '%s'",
-                                   commands::attributes::kDefault);
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidPropValue,
+                         "Invalid value for property '%s'",
+                         commands::attributes::kDefault);
       return false;
     }
     default_.value = std::move(prop_value);
@@ -231,7 +231,7 @@
 }
 
 bool PropType::ValidateConstraints(const PropValue& value,
-                                   chromeos::ErrorPtr* error) const {
+                                   ErrorPtr* error) const {
   for (const auto& pair : constraints_) {
     if (!pair.second->Validate(value, error))
       return false;
@@ -299,7 +299,7 @@
 static std::unique_ptr<Constraint> LoadOneOfConstraint(
     const base::DictionaryValue* value,
     const PropType* prop_type,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   std::unique_ptr<Constraint> constraint;
   const base::Value* list = nullptr;  // Owned by |value|
   CHECK(value->Get(commands::attributes::kOneOf_Enum, &list))
@@ -318,7 +318,7 @@
 static std::unique_ptr<Constraint> LoadMinMaxConstraint(
     const char* dict_key,
     const base::DictionaryValue* value,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   std::unique_ptr<Constraint> constraint;
   InheritableAttribute<T> limit;
 
@@ -338,7 +338,7 @@
 bool PropTypeBase<Derived, Value, T>::ConstraintsFromJson(
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   if (!PropType::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
@@ -363,7 +363,7 @@
 bool NumericPropTypeBase<Derived, Value, T>::ConstraintsFromJson(
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   if (!Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
@@ -398,7 +398,7 @@
 
 bool StringPropType::ConstraintsFromJson(const base::DictionaryValue* value,
                                          std::set<std::string>* processed_keys,
-                                         chromeos::ErrorPtr* error) {
+                                         ErrorPtr* error) {
   if (!Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
@@ -499,7 +499,7 @@
 bool ObjectPropType::ObjectSchemaFromJson(const base::DictionaryValue* value,
                                           const PropType* base_schema,
                                           std::set<std::string>* processed_keys,
-                                          chromeos::ErrorPtr* error) {
+                                          ErrorPtr* error) {
   if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
     return false;
 
@@ -517,20 +517,20 @@
     processed_keys->insert(kObject_Properties);
     object_schema.reset(new ObjectSchema);
     if (!object_schema->FromJson(props, base_object_schema, error)) {
-      chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                             errors::commands::kInvalidObjectSchema,
-                             "Error parsing object property schema");
+      Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+                   errors::commands::kInvalidObjectSchema,
+                   "Error parsing object property schema");
       return false;
     }
   } else if (base_object_schema) {
     object_schema = base_object_schema->Clone();
     inherited = true;
   } else {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                 errors::commands::kInvalidObjectSchema,
-                                 "Object type definition must include the "
-                                 "object schema ('%s' field not found)",
-                                 kObject_Properties);
+    Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                       errors::commands::kInvalidObjectSchema,
+                       "Object type definition must include the "
+                       "object schema ('%s' field not found)",
+                       kObject_Properties);
     return false;
   }
   bool extra_properties_allowed = false;
@@ -545,10 +545,10 @@
     processed_keys->insert(commands::attributes::kObject_Required);
     const base::ListValue* required_list = nullptr;
     if (!required->GetAsList(&required_list)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidObjectSchema,
-                                   "Property '%s' must be an array",
-                                   commands::attributes::kObject_Required);
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidObjectSchema,
+                         "Property '%s' must be an array",
+                         commands::attributes::kObject_Required);
       return false;
     }
     for (const base::Value* value : *required_list) {
@@ -556,7 +556,7 @@
       if (!value->GetAsString(&name)) {
         std::string json_value;
         CHECK(base::JSONWriter::Write(*value, &json_value));
-        chromeos::Error::AddToPrintf(
+        Error::AddToPrintf(
             error, FROM_HERE, errors::commands::kDomain,
             errors::commands::kInvalidObjectSchema,
             "Property '%s' contains invalid element (%s). String expected",
@@ -615,7 +615,7 @@
 bool ArrayPropType::ObjectSchemaFromJson(const base::DictionaryValue* value,
                                          const PropType* base_schema,
                                          std::set<std::string>* processed_keys,
-                                         chromeos::ErrorPtr* error) {
+                                         ErrorPtr* error) {
   if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
     return false;
 
@@ -632,9 +632,9 @@
     if (!item_type)
       return false;
     if (item_type->GetType() == ValueType::Array) {
-      chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                             errors::commands::kInvalidObjectSchema,
-                             "Arrays of arrays are not supported");
+      Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+                   errors::commands::kInvalidObjectSchema,
+                   "Arrays of arrays are not supported");
       return false;
     }
     SetItemType(std::move(item_type));
@@ -643,11 +643,11 @@
       item_type_.value = base_type->Clone();
       item_type_.is_inherited = true;
     } else {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidObjectSchema,
-                                   "Array type definition must include the "
-                                   "array item type ('%s' field not found)",
-                                   kItems);
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidObjectSchema,
+                         "Array type definition must include the "
+                         "array item type ('%s' field not found)",
+                         kItems);
       return false;
     }
   }
diff --git a/libweave/src/commands/prop_types.h b/libweave/src/commands/prop_types.h
index c8b1338..0960c3a 100644
--- a/libweave/src/commands/prop_types.h
+++ b/libweave/src/commands/prop_types.h
@@ -13,7 +13,7 @@
 #include <utility>
 #include <vector>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/prop_constraints.h"
 #include "libweave/src/commands/prop_values.h"
@@ -86,9 +86,8 @@
   virtual std::unique_ptr<PropType> Clone() const;
 
   // Creates an instance of associated value object.
-  virtual std::unique_ptr<PropValue> CreatePropValue(
-      const base::Value& value,
-      chromeos::ErrorPtr* error) const = 0;
+  virtual std::unique_ptr<PropValue> CreatePropValue(const base::Value& value,
+                                                     ErrorPtr* error) const = 0;
 
   // Saves the parameter type definition as a JSON object.
   // If |full_schema| is set to true, the full type definition is saved,
@@ -111,18 +110,18 @@
   // error information.
   virtual bool FromJson(const base::DictionaryValue* value,
                         const PropType* base_schema,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
   // Helper function to load object schema from JSON.
   virtual bool ObjectSchemaFromJson(const base::DictionaryValue* value,
                                     const PropType* base_schema,
                                     std::set<std::string>* processed_keys,
-                                    chromeos::ErrorPtr* error) {
+                                    ErrorPtr* error) {
     return true;
   }
   // Helper function to load type-specific constraints from JSON.
   virtual bool ConstraintsFromJson(const base::DictionaryValue* value,
                                    std::set<std::string>* processed_keys,
-                                   chromeos::ErrorPtr* error) {
+                                   ErrorPtr* error) {
     return true;
   }
 
@@ -152,8 +151,7 @@
   Constraint* GetConstraint(ConstraintType constraint_type);
 
   // Validates the given value against all the constraints.
-  bool ValidateConstraints(const PropValue& value,
-                           chromeos::ErrorPtr* error) const;
+  bool ValidateConstraints(const PropValue& value, ErrorPtr* error) const;
 
  protected:
   friend class StatePackage;
@@ -185,20 +183,19 @@
   // Overrides from PropType.
   ValueType GetType() const override { return GetValueType<T>(); }
 
-  std::unique_ptr<PropValue> CreatePropValue(
-      const base::Value& value,
-      chromeos::ErrorPtr* error) const override {
+  std::unique_ptr<PropValue> CreatePropValue(const base::Value& value,
+                                             ErrorPtr* error) const override {
     return CreateValue(value, error);
   }
 
   std::unique_ptr<Value> CreateValue(const base::Value& value,
-                                     chromeos::ErrorPtr* error) const {
+                                     ErrorPtr* error) const {
     return Value::CreateFromJson(value, *this, error);
   }
 
   bool ConstraintsFromJson(const base::DictionaryValue* value,
                            std::set<std::string>* processed_keys,
-                           chromeos::ErrorPtr* error) override;
+                           ErrorPtr* error) override;
 
  protected:
   std::unique_ptr<PropValue> CreateDefaultValue() const override {
@@ -215,7 +212,7 @@
   using Base = PropTypeBase<Derived, Value, T>;
   bool ConstraintsFromJson(const base::DictionaryValue* value,
                            std::set<std::string>* processed_keys,
-                           chromeos::ErrorPtr* error) override;
+                           ErrorPtr* error) override;
 
   // Helper method to set and obtain a min/max constraint values.
   // Used mostly for unit testing.
@@ -267,7 +264,7 @@
 
   bool ConstraintsFromJson(const base::DictionaryValue* value,
                            std::set<std::string>* processed_keys,
-                           chromeos::ErrorPtr* error) override;
+                           ErrorPtr* error) override;
 
   // Helper methods to add and inspect simple constraints.
   // Used mostly for unit testing.
@@ -305,7 +302,7 @@
   bool ObjectSchemaFromJson(const base::DictionaryValue* value,
                             const PropType* base_schema,
                             std::set<std::string>* processed_keys,
-                            chromeos::ErrorPtr* error) override;
+                            ErrorPtr* error) override;
 
   // Returns a schema for Object-type parameter.
   inline const ObjectSchema* GetObjectSchemaPtr() const {
@@ -338,7 +335,7 @@
   bool ObjectSchemaFromJson(const base::DictionaryValue* value,
                             const PropType* base_schema,
                             std::set<std::string>* processed_keys,
-                            chromeos::ErrorPtr* error) override;
+                            ErrorPtr* error) override;
 
   // Returns a type for Array elements.
   inline const PropType* GetItemTypePtr() const {
diff --git a/libweave/src/commands/prop_values.h b/libweave/src/commands/prop_values.h
index 939356a..cb8a662 100644
--- a/libweave/src/commands/prop_values.h
+++ b/libweave/src/commands/prop_values.h
@@ -9,7 +9,7 @@
 #include <memory>
 #include <string>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/schema_utils.h"
 
@@ -177,7 +177,7 @@
 
   static std::unique_ptr<Derived> CreateFromJson(const base::Value& value,
                                                  const PropType& type,
-                                                 chromeos::ErrorPtr* error) {
+                                                 ErrorPtr* error) {
     T tmp_value;
     if (!TypedValueFromJson(&value, &type, &tmp_value, error))
       return nullptr;
diff --git a/libweave/src/commands/schema_utils.cc b/libweave/src/commands/schema_utils.cc
index e2c8293..85455ed 100644
--- a/libweave/src/commands/schema_utils.cc
+++ b/libweave/src/commands/schema_utils.cc
@@ -20,13 +20,13 @@
 void ReportJsonTypeMismatch(const tracked_objects::Location& location,
                             const base::Value* value_in,
                             const std::string& expected_type,
-                            chromeos::ErrorPtr* error) {
+                            ErrorPtr* error) {
   std::string value_as_string;
   base::JSONWriter::Write(*value_in, &value_as_string);
-  chromeos::Error::AddToPrintf(error, location, errors::commands::kDomain,
-                               errors::commands::kTypeMismatch,
-                               "Unable to convert value %s into %s",
-                               value_as_string.c_str(), expected_type.c_str());
+  Error::AddToPrintf(error, location, errors::commands::kDomain,
+                     errors::commands::kTypeMismatch,
+                     "Unable to convert value %s into %s",
+                     value_as_string.c_str(), expected_type.c_str());
 }
 
 // Template version of ReportJsonTypeMismatch that deduces the type of expected
@@ -36,19 +36,19 @@
 bool ReportUnexpectedJson(const tracked_objects::Location& location,
                           const base::Value* value_in,
                           T*,
-                          chromeos::ErrorPtr* error) {
+                          ErrorPtr* error) {
   ReportJsonTypeMismatch(location, value_in,
                          PropType::GetTypeStringFromType(GetValueType<T>()),
                          error);
   return false;
 }
 
-bool ErrorMissingProperty(chromeos::ErrorPtr* error,
+bool ErrorMissingProperty(ErrorPtr* error,
                           const tracked_objects::Location& location,
                           const char* param_name) {
-  chromeos::Error::AddToPrintf(error, location, errors::commands::kDomain,
-                               errors::commands::kPropertyMissing,
-                               "Required parameter missing: %s", param_name);
+  Error::AddToPrintf(error, location, errors::commands::kDomain,
+                     errors::commands::kPropertyMissing,
+                     "Required parameter missing: %s", param_name);
   return false;
 }
 
@@ -97,7 +97,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         bool* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   return value_in->GetAsBoolean(value_out) ||
          ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
 }
@@ -105,7 +105,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         int* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   return value_in->GetAsInteger(value_out) ||
          ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
 }
@@ -113,7 +113,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         double* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   return value_in->GetAsDouble(value_out) ||
          ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
 }
@@ -121,7 +121,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         std::string* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   return value_in->GetAsString(value_out) ||
          ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
 }
@@ -129,7 +129,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         ValueMap* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   const base::DictionaryValue* dict = nullptr;
   if (!value_in->GetAsDictionary(&dict))
     return ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
@@ -148,10 +148,10 @@
           << "Unable to get parameter";
       auto value = pair.second->CreatePropValue(*param_value, error);
       if (!value) {
-        chromeos::Error::AddToPrintf(
-            error, FROM_HERE, errors::commands::kDomain,
-            errors::commands::kInvalidPropValue,
-            "Invalid value for property '%s'", pair.first.c_str());
+        Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                           errors::commands::kInvalidPropValue,
+                           "Invalid value for property '%s'",
+                           pair.first.c_str());
         return false;
       }
       value_out->emplace_hint(value_out->end(), pair.first, std::move(value));
@@ -172,9 +172,9 @@
     std::string key = iter.key();
     if (keys_processed.find(key) == keys_processed.end() &&
         !object_schema->GetExtraPropertiesAllowed()) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kUnknownProperty,
-                                   "Unrecognized parameter '%s'", key.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kUnknownProperty,
+                         "Unrecognized parameter '%s'", key.c_str());
       return false;
     }
     iter.Advance();
@@ -185,10 +185,9 @@
     const PropType* prop_type = pair.second->GetPropType();
     CHECK(prop_type) << "Value property type must be available";
     if (!prop_type->ValidateConstraints(*pair.second, error)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                   errors::commands::kInvalidPropValue,
-                                   "Invalid value for property '%s'",
-                                   pair.first.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                         errors::commands::kInvalidPropValue,
+                         "Invalid value for property '%s'", pair.first.c_str());
       return false;
     }
   }
@@ -198,7 +197,7 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         ValueVector* value_out,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
   const base::ListValue* list = nullptr;
   if (!value_in->GetAsList(&list))
     return ReportUnexpectedJson(FROM_HERE, value_in, value_out, error);
diff --git a/libweave/src/commands/schema_utils.h b/libweave/src/commands/schema_utils.h
index f00a89f..5691ddd 100644
--- a/libweave/src/commands/schema_utils.h
+++ b/libweave/src/commands/schema_utils.h
@@ -13,7 +13,7 @@
 #include <vector>
 
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -81,27 +81,27 @@
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         bool* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         int* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         double* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         std::string* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         ValueMap* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         ValueVector* value_out,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 
 bool operator==(const ValueMap& obj1, const ValueMap& obj2);
 bool operator==(const ValueVector& arr1, const ValueVector& arr2);
diff --git a/libweave/src/commands/schema_utils_unittest.cc b/libweave/src/commands/schema_utils_unittest.cc
index 8acb1ee..9dfadc3 100644
--- a/libweave/src/commands/schema_utils_unittest.cc
+++ b/libweave/src/commands/schema_utils_unittest.cc
@@ -79,7 +79,7 @@
       TypedValueFromJson(CreateValue("false").get(), nullptr, &value, nullptr));
   EXPECT_FALSE(value);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(
       TypedValueFromJson(CreateValue("0").get(), nullptr, &value, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
@@ -101,7 +101,7 @@
       TypedValueFromJson(CreateValue("-1234").get(), nullptr, &value, nullptr));
   EXPECT_EQ(-1234, value);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(
       TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
@@ -129,7 +129,7 @@
                                  &value, nullptr));
   EXPECT_EQ(-123.0, value);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(
       TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
@@ -151,7 +151,7 @@
       TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, nullptr));
   EXPECT_EQ("abc", value);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(
       TypedValueFromJson(CreateValue("12").get(), nullptr, &value, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
@@ -181,7 +181,7 @@
       "name", name_prop.CreateValue(base::StringValue("Bob"), nullptr)));
   EXPECT_EQ(value2, value);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(
       TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
@@ -202,7 +202,7 @@
   arr2.push_back(str_type.CreateValue(base::StringValue{"bar"}, nullptr));
   EXPECT_EQ(arr2, arr);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(TypedValueFromJson(CreateValue("['baz', 'ab']").get(), &type,
                                   &arr, &error));
   EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
diff --git a/libweave/src/commands/user_role.cc b/libweave/src/commands/user_role.cc
index 4f69849..f6b8c7d 100644
--- a/libweave/src/commands/user_role.cc
+++ b/libweave/src/commands/user_role.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include <weave/commands.h>
 #include <weave/enum_to_string.h>
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 3573cb8..d3dc1c0 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc
@@ -41,13 +41,12 @@
 
 namespace {
 
-inline void SetUnexpectedError(chromeos::ErrorPtr* error) {
-  chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
-                         "unexpected_response", "Unexpected GCD error");
+inline void SetUnexpectedError(ErrorPtr* error) {
+  Error::AddTo(error, FROM_HERE, kErrorDomainGCD, "unexpected_response",
+               "Unexpected GCD error");
 }
 
-void ParseGCDError(const base::DictionaryValue* json,
-                   chromeos::ErrorPtr* error) {
+void ParseGCDError(const base::DictionaryValue* json, ErrorPtr* error) {
   const base::Value* list_value = nullptr;
   const base::ListValue* error_list = nullptr;
   if (!json->Get("error.errors", &list_value) ||
@@ -67,8 +66,8 @@
     std::string error_code, error_message;
     if (error_object->GetString("reason", &error_code) &&
         error_object->GetString("message", &error_message)) {
-      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCDServer,
-                             error_code, error_message);
+      Error::AddTo(error, FROM_HERE, kErrorDomainGCDServer, error_code,
+                   error_message);
     } else {
       SetUnexpectedError(error);
     }
@@ -95,11 +94,9 @@
   return AppendQueryParams(result, params);
 }
 
-void IgnoreCloudError(const chromeos::Error*) {
-}
+void IgnoreCloudError(const Error*) {}
 
-void IgnoreCloudErrorWithCallback(const base::Closure& cb,
-                                  const chromeos::Error*) {
+void IgnoreCloudErrorWithCallback(const base::Closure& cb, const Error*) {
   cb.Run();
 }
 
@@ -118,8 +115,7 @@
                 HttpClient* transport)
       : method_{method}, url_{url}, transport_{transport} {}
 
-  std::unique_ptr<HttpClient::Response> SendAndBlock(
-      chromeos::ErrorPtr* error) {
+  std::unique_ptr<HttpClient::Response> SendAndBlock(ErrorPtr* error) {
     return transport_->SendRequestAndBlock(method_, url_, GetFullHeaders(),
                                            data_, error);
   }
@@ -172,16 +168,16 @@
 
 std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
     const HttpClient::Response& response,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   // Make sure we have a correct content type. Do not try to parse
   // binary files, or HTML output. Limit to application/json and text/plain.
   std::string content_type =
       SplitAtFirst(response.GetContentType(), ";", true).first;
 
   if (content_type != http::kJson && content_type != http::kPlain) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::json::kDomain,
-                           "non_json_content_type",
-                           "Unexpected response content type: " + content_type);
+    Error::AddTo(error, FROM_HERE, errors::json::kDomain,
+                 "non_json_content_type",
+                 "Unexpected response content type: " + content_type);
     return std::unique_ptr<base::DictionaryValue>();
   }
 
@@ -190,15 +186,15 @@
   auto value = base::JSONReader::ReadAndReturnError(json, base::JSON_PARSE_RFC,
                                                     nullptr, &error_message);
   if (!value) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                 errors::json::kParseError,
-                                 "Error '%s' occurred parsing JSON string '%s'",
-                                 error_message.c_str(), json.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                       errors::json::kParseError,
+                       "Error '%s' occurred parsing JSON string '%s'",
+                       error_message.c_str(), json.c_str());
     return std::unique_ptr<base::DictionaryValue>();
   }
   base::DictionaryValue* dict_value = nullptr;
   if (!value->GetAsDictionary(&dict_value)) {
-    chromeos::Error::AddToPrintf(
+    Error::AddToPrintf(
         error, FROM_HERE, errors::json::kDomain, errors::json::kObjectExpected,
         "Response is not a valid JSON object: '%s'", json.c_str());
     return std::unique_ptr<base::DictionaryValue>();
@@ -301,21 +297,20 @@
 }
 
 bool DeviceRegistrationInfo::VerifyRegistrationCredentials(
-    chromeos::ErrorPtr* error) const {
+    ErrorPtr* error) const {
   const bool have_credentials = HaveRegistrationCredentials();
 
   VLOG(2) << "Device registration record "
           << ((have_credentials) ? "found" : "not found.");
   if (!have_credentials)
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
-                           "device_not_registered",
-                           "No valid device registration record found");
+    Error::AddTo(error, FROM_HERE, kErrorDomainGCD, "device_not_registered",
+                 "No valid device registration record found");
   return have_credentials;
 }
 
 std::unique_ptr<base::DictionaryValue>
 DeviceRegistrationInfo::ParseOAuthResponse(const HttpClient::Response& response,
-                                           chromeos::ErrorPtr* error) {
+                                           ErrorPtr* error) {
   int code = response.GetStatusCode();
   auto resp = ParseJsonResponse(response, error);
   if (resp && code >= http::kBadRequest) {
@@ -331,8 +326,8 @@
     if (!resp->GetString("error_description", &error_message)) {
       error_message = "Unexpected OAuth error";
     }
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainOAuth2, error_code,
-                           error_message);
+    Error::AddTo(error, FROM_HERE, kErrorDomainOAuth2, error_code,
+                 error_message);
     return std::unique_ptr<base::DictionaryValue>();
   }
   return resp;
@@ -343,7 +338,7 @@
     const CloudRequestErrorCallback& error_callback) {
   LOG(INFO) << "Refreshing access token.";
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!VerifyRegistrationCredentials(&error)) {
     error_callback.Run(error.get());
     return;
@@ -394,7 +389,7 @@
     const HttpClient::Response& response) {
   VLOG(1) << "Refresh access token request with ID " << id << " completed";
   oauth2_backoff_entry_->InformOfRequest(true);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto json = ParseOAuthResponse(response, &error);
   if (!json) {
     error_callback->Run(error.get());
@@ -406,9 +401,8 @@
       !json->GetInteger("expires_in", &expires_in) || access_token_.empty() ||
       expires_in <= 0) {
     LOG(ERROR) << "Access token unavailable.";
-    chromeos::Error::AddTo(&error, FROM_HERE, kErrorDomainOAuth2,
-                           "unexpected_server_response",
-                           "Access token unavailable");
+    Error::AddTo(&error, FROM_HERE, kErrorDomainOAuth2,
+                 "unexpected_server_response", "Access token unavailable");
     error_callback->Run(error.get());
     return;
   }
@@ -430,7 +424,7 @@
     const std::shared_ptr<base::Closure>& success_callback,
     const std::shared_ptr<CloudRequestErrorCallback>& error_callback,
     int id,
-    const chromeos::Error* error) {
+    const Error* error) {
   VLOG(1) << "Refresh access token request with ID " << id << " failed";
   oauth2_backoff_entry_->InformOfRequest(false);
   RefreshAccessToken(*success_callback, *error_callback);
@@ -491,7 +485,7 @@
 }
 
 std::unique_ptr<base::DictionaryValue>
-DeviceRegistrationInfo::BuildDeviceResource(chromeos::ErrorPtr* error) {
+DeviceRegistrationInfo::BuildDeviceResource(ErrorPtr* error) {
   // Limit only to commands that are visible to the cloud.
   auto commands = command_manager_->GetCommandDictionary().GetCommandsAsJson(
       [](const CommandDefinition* def) { return def->GetVisibility().cloud; },
@@ -536,7 +530,7 @@
 }
 
 std::string DeviceRegistrationInfo::RegisterDevice(const std::string& ticket_id,
-                                                   chromeos::ErrorPtr* error) {
+                                                   ErrorPtr* error) {
   std::unique_ptr<base::DictionaryValue> device_draft =
       BuildDeviceResource(error);
   if (!device_draft)
@@ -585,9 +579,8 @@
       !json_resp->GetString("robotAccountAuthorizationCode", &auth_code) ||
       !json_resp->GetDictionary("deviceDraft", &device_draft_response) ||
       !device_draft_response->GetString("id", &device_id)) {
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
-                           "unexpected_response",
-                           "Device account missing in response");
+    Error::AddTo(error, FROM_HERE, kErrorDomainGCD, "unexpected_response",
+                 "Device account missing in response");
     return std::string();
   }
 
@@ -614,9 +607,8 @@
       !json_resp->GetString("refresh_token", &refresh_token) ||
       !json_resp->GetInteger("expires_in", &expires_in) ||
       access_token_.empty() || refresh_token.empty() || expires_in <= 0) {
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
-                           "unexpected_response",
-                           "Device access_token missing in response");
+    Error::AddTo(error, FROM_HERE, kErrorDomainGCD, "unexpected_response",
+                 "Device access_token missing in response");
     return std::string();
   }
 
@@ -665,7 +657,7 @@
 
   VLOG(1) << "Sending cloud request '" << data->method << "' to '" << data->url
           << "' with request body '" << data->body << "'";
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!VerifyRegistrationCredentials(&error)) {
     data->error_callback.Run(error.get());
     return;
@@ -719,7 +711,7 @@
     return;
   }
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto json_resp = ParseJsonResponse(response, &error);
   if (!json_resp) {
     data->error_callback.Run(error.get());
@@ -748,7 +740,7 @@
 void DeviceRegistrationInfo::OnCloudRequestError(
     const std::shared_ptr<const CloudRequestData>& data,
     int request_id,
-    const chromeos::Error* error) {
+    const Error* error) {
   VLOG(1) << "Cloud request with ID " << request_id << " failed";
   RetryCloudRequest(data);
 }
@@ -768,13 +760,12 @@
 
 void DeviceRegistrationInfo::OnAccessTokenError(
     const std::shared_ptr<const CloudRequestData>& data,
-    const chromeos::Error* error) {
+    const Error* error) {
   CheckAccessTokenError(error);
   data->error_callback.Run(error);
 }
 
-void DeviceRegistrationInfo::CheckAccessTokenError(
-    const chromeos::Error* error) {
+void DeviceRegistrationInfo::CheckAccessTokenError(const Error* error) {
   if (error->HasError(kErrorDomainOAuth2, "invalid_grant"))
     MarkDeviceUnregistered();
 }
@@ -816,7 +807,7 @@
 bool DeviceRegistrationInfo::UpdateDeviceInfo(const std::string& name,
                                               const std::string& description,
                                               const std::string& location,
-                                              chromeos::ErrorPtr* error) {
+                                              ErrorPtr* error) {
   BuffetConfig::Transaction change{config_.get()};
   change.set_name(name);
   change.set_description(description);
@@ -835,12 +826,11 @@
     const std::string& anonymous_access_role,
     bool local_discovery_enabled,
     bool local_pairing_enabled,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   BuffetConfig::Transaction change(config_.get());
   if (!change.set_local_anonymous_access_role(anonymous_access_role)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain,
-                                 "invalid_parameter", "Invalid role: %s",
-                                 anonymous_access_role.c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, "invalid_parameter",
+                       "Invalid role: %s", anonymous_access_role.c_str());
     return false;
   }
 
@@ -856,10 +846,10 @@
     const std::string& api_key,
     const std::string& oauth_url,
     const std::string& service_url,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   if (HaveRegistrationCredentials()) {
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, "already_registered",
-                           "Unable to change config for registered device");
+    Error::AddTo(error, FROM_HERE, kErrorDomain, "already_registered",
+                 "Unable to change config for registered device");
     return false;
   }
   BuffetConfig::Transaction change{config_.get()};
@@ -883,7 +873,7 @@
 }
 
 void DeviceRegistrationInfo::NotifyCommandAborted(const std::string& command_id,
-                                                  chromeos::ErrorPtr error) {
+                                                  ErrorPtr error) {
   base::DictionaryValue command_patch;
   command_patch.SetString(commands::attributes::kCommand_State,
                           EnumToString(CommandStatus::kAborted));
@@ -891,7 +881,7 @@
     command_patch.SetString(commands::attributes::kCommand_ErrorCode,
                             Join(":", error->GetDomain(), error->GetCode()));
     std::vector<std::string> messages;
-    const chromeos::Error* current_error = error.get();
+    const Error* current_error = error.get();
     while (current_error) {
       messages.push_back(current_error->GetMessage());
       current_error = current_error->GetInnerError();
@@ -940,7 +930,7 @@
   queued_resource_update_callbacks_.clear();
 
   VLOG(1) << "Updating GCD server with CDD...";
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   std::unique_ptr<base::DictionaryValue> device_resource =
       BuildDeviceResource(&error);
   if (!device_resource) {
@@ -991,8 +981,7 @@
   StartQueuedUpdateDeviceResource();
 }
 
-void DeviceRegistrationInfo::OnUpdateDeviceResourceError(
-    const chromeos::Error* error) {
+void DeviceRegistrationInfo::OnUpdateDeviceResourceError(const Error* error) {
   if (error->HasError(kErrorDomainGCDServer, "invalid_last_update_time_ms")) {
     // If the server rejected our previous request, retrieve the latest
     // timestamp from the server and retry.
@@ -1093,7 +1082,7 @@
 void DeviceRegistrationInfo::PublishCommand(
     const base::DictionaryValue& command) {
   std::string command_id;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   auto command_instance = CommandInstance::FromJson(
       &command, CommandOrigin::kCloud, command_manager_->GetCommandDictionary(),
       &command_id, &error);
@@ -1177,7 +1166,7 @@
   PublishStateUpdates();
 }
 
-void DeviceRegistrationInfo::OnPublishStateError(const chromeos::Error* error) {
+void DeviceRegistrationInfo::OnPublishStateError(const Error* error) {
   LOG(ERROR) << "Permanent failure while trying to update device state";
   device_state_update_pending_ = false;
 }
diff --git a/libweave/src/device_registration_info.h b/libweave/src/device_registration_info.h
index e0515a9..1dcc41b 100644
--- a/libweave/src/device_registration_info.h
+++ b/libweave/src/device_registration_info.h
@@ -18,7 +18,7 @@
 #include <base/single_thread_task_runner.h>
 #include <base/time/time.h>
 #include <base/timer/timer.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/cloud.h>
 #include <weave/config.h>
 #include <weave/http_client.h>
@@ -59,8 +59,7 @@
  public:
   using CloudRequestCallback =
       base::Callback<void(const base::DictionaryValue& response)>;
-  using CloudRequestErrorCallback =
-      base::Callback<void(const chromeos::Error* error)>;
+  using CloudRequestErrorCallback = base::Callback<void(const Error* error)>;
 
   DeviceRegistrationInfo(const std::shared_ptr<CommandManager>& command_manager,
                          const std::shared_ptr<StateManager>& state_manager,
@@ -79,21 +78,21 @@
       const OnCloudRequestCallback& success_callback,
       const OnCloudRequestErrorCallback& error_callback) override;
   std::string RegisterDevice(const std::string& ticket_id,
-                             chromeos::ErrorPtr* error) override;
+                             ErrorPtr* error) override;
   bool UpdateDeviceInfo(const std::string& name,
                         const std::string& description,
                         const std::string& location,
-                        chromeos::ErrorPtr* error) override;
+                        ErrorPtr* error) override;
   bool UpdateBaseConfig(const std::string& anonymous_access_role,
                         bool local_discovery_enabled,
                         bool local_pairing_enabled,
-                        chromeos::ErrorPtr* error) override;
+                        ErrorPtr* error) override;
   bool UpdateServiceConfig(const std::string& client_id,
                            const std::string& client_secret,
                            const std::string& api_key,
                            const std::string& oauth_url,
                            const std::string& service_url,
-                           chromeos::ErrorPtr* error) override;
+                           ErrorPtr* error) override;
 
   // Add callback to listen for changes in config.
   void AddOnConfigChangedCallback(const Config::OnChangedCallback& callback);
@@ -129,7 +128,7 @@
   bool HaveRegistrationCredentials() const;
   // Calls HaveRegistrationCredentials() and logs an error if no credentials
   // are available.
-  bool VerifyRegistrationCredentials(chromeos::ErrorPtr* error) const;
+  bool VerifyRegistrationCredentials(ErrorPtr* error) const;
 
   // Updates a command (override from CloudCommandUpdateInterface).
   void UpdateCommand(const std::string& command_id,
@@ -173,13 +172,13 @@
       const std::shared_ptr<base::Closure>& success_callback,
       const std::shared_ptr<CloudRequestErrorCallback>& error_callback,
       int id,
-      const chromeos::Error* error);
+      const Error* error);
 
   // Parse the OAuth response, and sets registration status to
   // kInvalidCredentials if our registration is no longer valid.
   std::unique_ptr<base::DictionaryValue> ParseOAuthResponse(
       const HttpClient::Response& response,
-      chromeos::ErrorPtr* error);
+      ErrorPtr* error);
 
   // This attempts to open a notification channel. The channel needs to be
   // restarted anytime the access_token is refreshed.
@@ -211,21 +210,20 @@
       const HttpClient::Response& response);
   void OnCloudRequestError(const std::shared_ptr<const CloudRequestData>& data,
                            int request_id,
-                           const chromeos::Error* error);
+                           const Error* error);
   void RetryCloudRequest(const std::shared_ptr<const CloudRequestData>& data);
   void OnAccessTokenRefreshed(
       const std::shared_ptr<const CloudRequestData>& data);
-  void OnAccessTokenError(
-      const std::shared_ptr<const CloudRequestData>& data,
-      const chromeos::Error* error);
-  void CheckAccessTokenError(const chromeos::Error* error);
+  void OnAccessTokenError(const std::shared_ptr<const CloudRequestData>& data,
+                          const Error* error);
+  void CheckAccessTokenError(const Error* error);
 
   void UpdateDeviceResource(const base::Closure& on_success,
                             const CloudRequestErrorCallback& on_failure);
   void StartQueuedUpdateDeviceResource();
   // Success/failure callbacks for UpdateDeviceResource().
   void OnUpdateDeviceResourceSuccess(const base::DictionaryValue& device_info);
-  void OnUpdateDeviceResourceError(const chromeos::Error* error);
+  void OnUpdateDeviceResourceError(const Error* error);
 
   // Callback from GetDeviceInfo() to retrieve the device resource timestamp
   // and retry UpdateDeviceResource() call.
@@ -256,18 +254,16 @@
   void PublishStateUpdates();
   void OnPublishStateSuccess(StateChangeQueueInterface::UpdateID update_id,
                              const base::DictionaryValue& reply);
-  void OnPublishStateError(const chromeos::Error* error);
+  void OnPublishStateError(const Error* error);
 
   // If unrecoverable error occurred (e.g. error parsing command instance),
   // notify the server that the command is aborted by the device.
-  void NotifyCommandAborted(const std::string& command_id,
-                            chromeos::ErrorPtr error);
+  void NotifyCommandAborted(const std::string& command_id, ErrorPtr error);
 
   // Builds Cloud API devices collection REST resource which matches
   // current state of the device including command definitions
   // for all supported commands and current device state.
-  std::unique_ptr<base::DictionaryValue> BuildDeviceResource(
-      chromeos::ErrorPtr* error);
+  std::unique_ptr<base::DictionaryValue> BuildDeviceResource(ErrorPtr* error);
 
   void SetRegistrationStatus(RegistrationStatus new_status);
   void SetDeviceId(const std::string& device_id);
diff --git a/libweave/src/device_registration_info_unittest.cc b/libweave/src/device_registration_info_unittest.cc
index 75c812b..c73b55a 100644
--- a/libweave/src/device_registration_info_unittest.cc
+++ b/libweave/src/device_registration_info_unittest.cc
@@ -159,10 +159,10 @@
     return dev_reg_->PublishCommands(commands);
   }
 
-  bool RefreshAccessToken(chromeos::ErrorPtr* error) const {
+  bool RefreshAccessToken(ErrorPtr* error) const {
     bool succeeded = false;
     auto on_success = [&succeeded]() { succeeded = true; };
-    auto on_failure = [&error](const chromeos::Error* in_error) {
+    auto on_failure = [&error](const Error* in_error) {
       if (error)
         *error = in_error->Clone();
     };
@@ -271,7 +271,7 @@
         return ReplyWithJson(400, json);
       })));
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(RefreshAccessToken(&error));
   EXPECT_TRUE(error->HasError(kErrorDomainOAuth2, "unable_to_authenticate"));
   EXPECT_EQ(RegistrationStatus::kConnecting, GetRegistrationStatus());
@@ -299,7 +299,7 @@
         return ReplyWithJson(400, json);
       })));
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(RefreshAccessToken(&error));
   EXPECT_TRUE(error->HasError(kErrorDomainOAuth2, "invalid_grant"));
   EXPECT_EQ(RegistrationStatus::kInvalidCredentials, GetRegistrationStatus());
@@ -331,7 +331,7 @@
     EXPECT_EQ(test_data::kDeviceId, id);
     succeeded = true;
   };
-  auto on_failure = [](const chromeos::Error* error) {
+  auto on_failure = [](const Error* error) {
     FAIL() << "Should not be called";
   };
   dev_reg_->GetDeviceInfo(base::Bind(on_success), base::Bind(on_failure));
diff --git a/libweave/src/error.cc b/libweave/src/error.cc
new file mode 100644
index 0000000..92ee42e
--- /dev/null
+++ b/libweave/src/error.cc
@@ -0,0 +1,135 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <weave/error.h>
+
+#include <base/logging.h>
+#include <base/strings/stringprintf.h>
+
+namespace weave {
+
+namespace {
+inline void LogError(const tracked_objects::Location& location,
+                     const std::string& domain,
+                     const std::string& code,
+                     const std::string& message) {
+  // Use logging::LogMessage() directly instead of LOG(ERROR) to substitute
+  // the current error location with the location passed in to the Error object.
+  // This way the log will contain the actual location of the error, and not
+  // as if it always comes from chromeos/errors/error.cc(22).
+  logging::LogMessage(location.file_name(), location.line_number(),
+                      logging::LOG_ERROR)
+          .stream()
+      << location.function_name() << "(...): "
+      << "Domain=" << domain << ", Code=" << code << ", Message=" << message;
+}
+}  // anonymous namespace
+
+ErrorPtr Error::Create(const tracked_objects::Location& location,
+                       const std::string& domain,
+                       const std::string& code,
+                       const std::string& message) {
+  return Create(location, domain, code, message, ErrorPtr());
+}
+
+ErrorPtr Error::Create(const tracked_objects::Location& location,
+                       const std::string& domain,
+                       const std::string& code,
+                       const std::string& message,
+                       ErrorPtr inner_error) {
+  LogError(location, domain, code, message);
+  return ErrorPtr(
+      new Error(location, domain, code, message, std::move(inner_error)));
+}
+
+void Error::AddTo(ErrorPtr* error,
+                  const tracked_objects::Location& location,
+                  const std::string& domain,
+                  const std::string& code,
+                  const std::string& message) {
+  if (error) {
+    *error = Create(location, domain, code, message, std::move(*error));
+  } else {
+    // Create already logs the error, but if |error| is nullptr,
+    // we still want to log the error...
+    LogError(location, domain, code, message);
+  }
+}
+
+void Error::AddToPrintf(ErrorPtr* error,
+                        const tracked_objects::Location& location,
+                        const std::string& domain,
+                        const std::string& code,
+                        const char* format,
+                        ...) {
+  va_list ap;
+  va_start(ap, format);
+  std::string message = base::StringPrintV(format, ap);
+  va_end(ap);
+  AddTo(error, location, domain, code, message);
+}
+
+ErrorPtr Error::Clone() const {
+  ErrorPtr inner_error = inner_error_ ? inner_error_->Clone() : nullptr;
+  return ErrorPtr(
+      new Error(location_, domain_, code_, message_, std::move(inner_error)));
+}
+
+bool Error::HasDomain(const std::string& domain) const {
+  return FindErrorOfDomain(this, domain) != nullptr;
+}
+
+bool Error::HasError(const std::string& domain, const std::string& code) const {
+  return FindError(this, domain, code) != nullptr;
+}
+
+const Error* Error::GetFirstError() const {
+  const Error* err = this;
+  while (err->GetInnerError())
+    err = err->GetInnerError();
+  return err;
+}
+
+Error::Error(const tracked_objects::Location& location,
+             const std::string& domain,
+             const std::string& code,
+             const std::string& message,
+             ErrorPtr inner_error)
+    : Error{tracked_objects::LocationSnapshot{location}, domain, code, message,
+            std::move(inner_error)} {}
+
+Error::Error(const tracked_objects::LocationSnapshot& location,
+             const std::string& domain,
+             const std::string& code,
+             const std::string& message,
+             ErrorPtr inner_error)
+    : domain_(domain),
+      code_(code),
+      message_(message),
+      location_(location),
+      inner_error_(std::move(inner_error)) {}
+
+const Error* Error::FindErrorOfDomain(const Error* error_chain_start,
+                                      const std::string& domain) {
+  while (error_chain_start) {
+    if (error_chain_start->GetDomain() == domain)
+      break;
+    error_chain_start = error_chain_start->GetInnerError();
+  }
+  return error_chain_start;
+}
+
+const Error* Error::FindError(const Error* error_chain_start,
+                              const std::string& domain,
+                              const std::string& code) {
+  while (error_chain_start) {
+    if (error_chain_start->GetDomain() == domain &&
+        error_chain_start->GetCode() == code)
+      break;
+    error_chain_start = error_chain_start->GetInnerError();
+  }
+  return error_chain_start;
+}
+
+}  // namespace weave
diff --git a/libweave/src/error_unittest.cc b/libweave/src/error_unittest.cc
new file mode 100644
index 0000000..36028fb
--- /dev/null
+++ b/libweave/src/error_unittest.cc
@@ -0,0 +1,83 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <weave/error.h>
+
+#include <gtest/gtest.h>
+
+namespace weave {
+
+namespace {
+
+ErrorPtr GenerateNetworkError() {
+  tracked_objects::Location loc("GenerateNetworkError", "error_unittest.cc", 15,
+                                ::tracked_objects::GetProgramCounter());
+  return Error::Create(loc, "network", "not_found", "Resource not found");
+}
+
+ErrorPtr GenerateHttpError() {
+  ErrorPtr inner = GenerateNetworkError();
+  return Error::Create(FROM_HERE, "HTTP", "404", "Not found", std::move(inner));
+}
+
+}  // namespace
+
+TEST(Error, Single) {
+  ErrorPtr err = GenerateNetworkError();
+  EXPECT_EQ("network", err->GetDomain());
+  EXPECT_EQ("not_found", err->GetCode());
+  EXPECT_EQ("Resource not found", err->GetMessage());
+  EXPECT_EQ("GenerateNetworkError", err->GetLocation().function_name);
+  EXPECT_EQ("error_unittest.cc", err->GetLocation().file_name);
+  EXPECT_EQ(15, err->GetLocation().line_number);
+  EXPECT_EQ(nullptr, err->GetInnerError());
+  EXPECT_TRUE(err->HasDomain("network"));
+  EXPECT_FALSE(err->HasDomain("HTTP"));
+  EXPECT_FALSE(err->HasDomain("foo"));
+  EXPECT_TRUE(err->HasError("network", "not_found"));
+  EXPECT_FALSE(err->HasError("network", "404"));
+  EXPECT_FALSE(err->HasError("HTTP", "404"));
+  EXPECT_FALSE(err->HasError("HTTP", "not_found"));
+  EXPECT_FALSE(err->HasError("foo", "bar"));
+}
+
+TEST(Error, Nested) {
+  ErrorPtr err = GenerateHttpError();
+  EXPECT_EQ("HTTP", err->GetDomain());
+  EXPECT_EQ("404", err->GetCode());
+  EXPECT_EQ("Not found", err->GetMessage());
+  EXPECT_NE(nullptr, err->GetInnerError());
+  EXPECT_EQ("network", err->GetInnerError()->GetDomain());
+  EXPECT_TRUE(err->HasDomain("network"));
+  EXPECT_TRUE(err->HasDomain("HTTP"));
+  EXPECT_FALSE(err->HasDomain("foo"));
+  EXPECT_TRUE(err->HasError("network", "not_found"));
+  EXPECT_FALSE(err->HasError("network", "404"));
+  EXPECT_TRUE(err->HasError("HTTP", "404"));
+  EXPECT_FALSE(err->HasError("HTTP", "not_found"));
+  EXPECT_FALSE(err->HasError("foo", "bar"));
+}
+
+TEST(Error, Clone) {
+  ErrorPtr err = GenerateHttpError();
+  ErrorPtr clone = err->Clone();
+  const Error* error1 = err.get();
+  const Error* error2 = clone.get();
+  while (error1 && error2) {
+    EXPECT_NE(error1, error2);
+    EXPECT_EQ(error1->GetDomain(), error2->GetDomain());
+    EXPECT_EQ(error1->GetCode(), error2->GetCode());
+    EXPECT_EQ(error1->GetMessage(), error2->GetMessage());
+    EXPECT_EQ(error1->GetLocation().function_name,
+              error2->GetLocation().function_name);
+    EXPECT_EQ(error1->GetLocation().file_name, error2->GetLocation().file_name);
+    EXPECT_EQ(error1->GetLocation().line_number,
+              error2->GetLocation().line_number);
+    error1 = error1->GetInnerError();
+    error2 = error2->GetInnerError();
+  }
+  EXPECT_EQ(error1, error2);
+}
+
+}  // namespace weave
diff --git a/libweave/src/mock_http_client.cc b/libweave/src/mock_http_client.cc
index 1f223a9..a1d7160 100644
--- a/libweave/src/mock_http_client.cc
+++ b/libweave/src/mock_http_client.cc
@@ -15,7 +15,7 @@
     const std::string& url,
     const Headers& headers,
     const std::string& data,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   return std::unique_ptr<Response>{
       MockSendRequest(method, url, headers, data, error)};
 }
@@ -26,7 +26,7 @@
                                 const std::string& data,
                                 const SuccessCallback& success_callback,
                                 const ErrorCallback& error_callback) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   std::unique_ptr<Response> response{
       MockSendRequest(method, url, headers, data, &error)};
   if (response) {
diff --git a/libweave/src/notification/pull_channel.cc b/libweave/src/notification/pull_channel.cc
index d358e95..2342e7d 100644
--- a/libweave/src/notification/pull_channel.cc
+++ b/libweave/src/notification/pull_channel.cc
@@ -5,6 +5,7 @@
 #include "libweave/src/notification/pull_channel.h"
 
 #include <base/bind.h>
+#include <base/location.h>
 #include <weave/task_runner.h>
 
 #include "libweave/src/notification/notification_delegate.h"
diff --git a/libweave/src/notification/xmpp_channel.cc b/libweave/src/notification/xmpp_channel.cc
index de0ba44..90d35d2 100644
--- a/libweave/src/notification/xmpp_channel.cc
+++ b/libweave/src/notification/xmpp_channel.cc
@@ -307,7 +307,7 @@
   RestartXmppStream();
 }
 
-void XmppChannel::OnTlsError(const chromeos::Error* error) {
+void XmppChannel::OnTlsError(const Error* error) {
   LOG(ERROR) << "TLS handshake failed. Restarting XMPP connection";
   Restart();
 }
@@ -320,7 +320,7 @@
   }
   write_socket_data_ = queued_write_data_ + message;
   queued_write_data_.clear();
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   VLOG(2) << "Sending XMPP message: " << message;
 
   write_pending_ = true;
@@ -335,7 +335,7 @@
 }
 
 void XmppChannel::OnMessageSent() {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   write_pending_ = false;
   if (!stream_->FlushBlocking(&error)) {
     OnWriteError(error.get());
@@ -352,7 +352,7 @@
   if (read_pending_ || !stream_)
     return;
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   read_pending_ = true;
   bool ok = stream_->ReadAsync(
       read_socket_data_.data(), read_socket_data_.size(),
@@ -364,12 +364,12 @@
     OnReadError(error.get());
 }
 
-void XmppChannel::OnReadError(const chromeos::Error* error) {
+void XmppChannel::OnReadError(const Error* error) {
   read_pending_ = false;
   Restart();
 }
 
-void XmppChannel::OnWriteError(const chromeos::Error* error) {
+void XmppChannel::OnWriteError(const Error* error) {
   write_pending_ = false;
   Restart();
 }
diff --git a/libweave/src/notification/xmpp_channel.h b/libweave/src/notification/xmpp_channel.h
index 2f26748..112799f 100644
--- a/libweave/src/notification/xmpp_channel.h
+++ b/libweave/src/notification/xmpp_channel.h
@@ -105,15 +105,15 @@
 
   void StartTlsHandshake();
   void OnTlsHandshakeComplete(std::unique_ptr<Stream> tls_stream);
-  void OnTlsError(const chromeos::Error* error);
+  void OnTlsError(const Error* error);
 
   void WaitForMessage();
 
   void OnConnected();
   void OnMessageRead(size_t size);
   void OnMessageSent();
-  void OnReadError(const chromeos::Error* error);
-  void OnWriteError(const chromeos::Error* error);
+  void OnReadError(const Error* error);
+  void OnWriteError(const Error* error);
   void Restart();
   void CloseStream();
 
diff --git a/libweave/src/notification/xmpp_channel_unittest.cc b/libweave/src/notification/xmpp_channel_unittest.cc
index 5a1b86d..1816288 100644
--- a/libweave/src/notification/xmpp_channel_unittest.cc
+++ b/libweave/src/notification/xmpp_channel_unittest.cc
@@ -85,9 +85,9 @@
  public:
   explicit FakeStream(TaskRunner* task_runner) : task_runner_{task_runner} {}
 
-  bool FlushBlocking(chromeos::ErrorPtr* error) override { return true; }
+  bool FlushBlocking(ErrorPtr* error) override { return true; }
 
-  bool CloseBlocking(chromeos::ErrorPtr* error) override { return true; }
+  bool CloseBlocking(ErrorPtr* error) override { return true; }
 
   void CancelPendingAsyncOperations() override {}
 
@@ -99,12 +99,11 @@
     read_data_ += data;
   }
 
-  bool ReadAsync(
-      void* buffer,
-      size_t size_to_read,
-      const base::Callback<void(size_t)>& success_callback,
-      const base::Callback<void(const chromeos::Error*)>& error_callback,
-      chromeos::ErrorPtr* error) override {
+  bool ReadAsync(void* buffer,
+                 size_t size_to_read,
+                 const base::Callback<void(size_t)>& success_callback,
+                 const base::Callback<void(const Error*)>& error_callback,
+                 ErrorPtr* error) override {
     size_t size = std::min(size_to_read, read_data_.size());
     memcpy(buffer, read_data_.data(), size);
     read_data_ = read_data_.substr(size);
@@ -113,12 +112,11 @@
     return true;
   }
 
-  bool WriteAllAsync(
-      const void* buffer,
-      size_t size_to_write,
-      const base::Closure& success_callback,
-      const base::Callback<void(const chromeos::Error*)>& error_callback,
-      chromeos::ErrorPtr* error) override {
+  bool WriteAllAsync(const void* buffer,
+                     size_t size_to_write,
+                     const base::Closure& success_callback,
+                     const base::Callback<void(const Error*)>& error_callback,
+                     ErrorPtr* error) override {
     size_t size = std::min(size_to_write, write_data_.size());
     EXPECT_EQ(
         write_data_.substr(0, size),
diff --git a/libweave/src/privet/cloud_delegate.cc b/libweave/src/privet/cloud_delegate.cc
index f2cbdbf..3a2a249 100644
--- a/libweave/src/privet/cloud_delegate.cc
+++ b/libweave/src/privet/cloud_delegate.cc
@@ -11,7 +11,7 @@
 #include <base/logging.h>
 #include <base/memory/weak_ptr.h>
 #include <base/values.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/task_runner.h>
 
 #include "libweave/src/buffet_config.h"
@@ -20,8 +20,6 @@
 #include "libweave/src/privet/constants.h"
 #include "libweave/src/states/state_manager.h"
 
-using chromeos::ErrorPtr;
-
 namespace weave {
 namespace privet {
 
@@ -30,11 +28,9 @@
 const int kMaxSetupRetries = 5;
 const int kFirstRetryTimeoutSec = 1;
 
-Command* ReturnNotFound(const std::string& command_id,
-                        chromeos::ErrorPtr* error) {
-  chromeos::Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                               errors::kNotFound, "Command not found, ID='%s'",
-                               command_id.c_str());
+Command* ReturnNotFound(const std::string& command_id, ErrorPtr* error) {
+  Error::AddToPrintf(error, FROM_HERE, errors::kDomain, errors::kNotFound,
+                     "Command not found, ID='%s'", command_id.c_str());
   return nullptr;
 }
 
@@ -66,18 +62,18 @@
 
   ~CloudDelegateImpl() override = default;
 
-  bool GetModelId(std::string* id, chromeos::ErrorPtr* error) const override {
+  bool GetModelId(std::string* id, ErrorPtr* error) const override {
     if (device_->GetConfig().model_id().size() != 5) {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, errors::kDomain, errors::kInvalidState,
-          "Model ID is invalid: %s", device_->GetConfig().model_id().c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidState, "Model ID is invalid: %s",
+                         device_->GetConfig().model_id().c_str());
       return false;
     }
     *id = device_->GetConfig().model_id();
     return true;
   }
 
-  bool GetName(std::string* name, chromeos::ErrorPtr* error) const override {
+  bool GetName(std::string* name, ErrorPtr* error) const override {
     *name = device_->GetConfig().name();
     return true;
   }
@@ -95,7 +91,7 @@
                         const std::string& location,
                         const base::Closure& success_callback,
                         const ErrorCallback& error_callback) override {
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     if (!device_->UpdateDeviceInfo(name, description, location, &error))
       return error_callback.Run(error.get());
     success_callback.Run();
@@ -135,10 +131,10 @@
 
   bool Setup(const std::string& ticket_id,
              const std::string& user,
-             chromeos::ErrorPtr* error) override {
+             ErrorPtr* error) override {
     if (setup_state_.IsStatusEqual(SetupState::kInProgress)) {
-      chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                             errors::kDeviceBusy, "Setup in progress");
+      Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kDeviceBusy,
+                   "Setup in progress");
       return false;
     }
     VLOG(1) << "GCD Setup started. ticket_id: " << ticket_id
@@ -170,13 +166,13 @@
     CHECK(user_info.scope() != AuthScope::kNone);
     CHECK_NE(user_info.user_id(), 0u);
 
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     UserRole role;
     std::string str_scope = EnumToString(user_info.scope());
     if (!StringToEnum(str_scope, &role)) {
-      chromeos::Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                                   errors::kInvalidParams, "Invalid role: '%s'",
-                                   str_scope.c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidParams, "Invalid role: '%s'",
+                         str_scope.c_str());
       return error_callback.Run(error.get());
     }
 
@@ -193,7 +189,7 @@
                   const SuccessCallback& success_callback,
                   const ErrorCallback& error_callback) override {
     CHECK(user_info.scope() != AuthScope::kNone);
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     auto command = GetCommandInternal(id, user_info, &error);
     if (!command)
       return error_callback.Run(error.get());
@@ -205,7 +201,7 @@
                      const SuccessCallback& success_callback,
                      const ErrorCallback& error_callback) override {
     CHECK(user_info.scope() != AuthScope::kNone);
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     auto command = GetCommandInternal(id, user_info, &error);
     if (!command)
       return error_callback.Run(error.get());
@@ -255,8 +251,8 @@
     } else if (status == RegistrationStatus::kConnected) {
       connection_state_ = ConnectionState{ConnectionState::kOnline};
     } else {
-      chromeos::ErrorPtr error;
-      chromeos::Error::AddToPrintf(
+      ErrorPtr error;
+      Error::AddToPrintf(
           &error, FROM_HERE, errors::kDomain, errors::kInvalidState,
           "Unexpected registration status: %s", EnumToString(status).c_str());
       connection_state_ = ConnectionState{std::move(error)};
@@ -282,14 +278,11 @@
     NotifyOnCommandDefsChanged();
   }
 
-  void RetryRegister(const std::string& ticket_id,
-                     int retries,
-                     chromeos::Error* error) {
+  void RetryRegister(const std::string& ticket_id, int retries, Error* error) {
     if (retries >= kMaxSetupRetries) {
-      chromeos::ErrorPtr new_error{error ? error->Clone() : nullptr};
-      chromeos::Error::AddTo(&new_error, FROM_HERE, errors::kDomain,
-                             errors::kInvalidState,
-                             "Failed to register device");
+      ErrorPtr new_error{error ? error->Clone() : nullptr};
+      Error::AddTo(&new_error, FROM_HERE, errors::kDomain,
+                   errors::kInvalidState, "Failed to register device");
       setup_state_ = SetupState{std::move(new_error)};
       return;
     }
@@ -306,7 +299,7 @@
   }
 
   void CallManagerRegisterDevice(const std::string& ticket_id, int retries) {
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     if (device_->RegisterDevice(ticket_id, &error).empty())
       return RetryRegister(ticket_id, retries, error.get());
     setup_state_ = SetupState(SetupState::kSuccess);
@@ -314,7 +307,7 @@
 
   Command* GetCommandInternal(const std::string& command_id,
                               const UserInfo& user_info,
-                              chromeos::ErrorPtr* error) const {
+                              ErrorPtr* error) const {
     if (user_info.scope() != AuthScope::kOwner) {
       auto it = command_owners_.find(command_id);
       if (it == command_owners_.end())
@@ -332,7 +325,7 @@
 
   bool CanAccessCommand(uint64_t owner_id,
                         const UserInfo& user_info,
-                        chromeos::ErrorPtr* error) const {
+                        ErrorPtr* error) const {
     CHECK(user_info.scope() != AuthScope::kNone);
     CHECK_NE(user_info.user_id(), 0u);
 
@@ -341,9 +334,8 @@
       return true;
     }
 
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                           errors::kAccessDenied,
-                           "Need to be owner of the command.");
+    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kAccessDenied,
+                 "Need to be owner of the command.");
     return false;
   }
 
diff --git a/libweave/src/privet/cloud_delegate.h b/libweave/src/privet/cloud_delegate.h
index 3b80b2e..5f79a6d 100644
--- a/libweave/src/privet/cloud_delegate.h
+++ b/libweave/src/privet/cloud_delegate.h
@@ -37,7 +37,7 @@
   virtual ~CloudDelegate();
 
   using SuccessCallback = base::Callback<void(const base::DictionaryValue&)>;
-  using ErrorCallback = base::Callback<void(chromeos::Error*)>;
+  using ErrorCallback = base::Callback<void(Error*)>;
 
   class Observer {
    public:
@@ -49,10 +49,10 @@
   };
 
   // Returns the model ID of the device.
-  virtual bool GetModelId(std::string* id, chromeos::ErrorPtr* error) const = 0;
+  virtual bool GetModelId(std::string* id, ErrorPtr* error) const = 0;
 
   // Returns the name of device.
-  virtual bool GetName(std::string* name, chromeos::ErrorPtr* error) const = 0;
+  virtual bool GetName(std::string* name, ErrorPtr* error) const = 0;
 
   // Returns the description of the device.
   virtual std::string GetDescription() const = 0;
@@ -89,7 +89,7 @@
   // Starts GCD setup.
   virtual bool Setup(const std::string& ticket_id,
                      const std::string& user,
-                     chromeos::ErrorPtr* error) = 0;
+                     ErrorPtr* error) = 0;
 
   // Returns cloud id if the registered device or empty string if unregistered.
   virtual std::string GetCloudId() const = 0;
diff --git a/libweave/src/privet/mock_delegates.h b/libweave/src/privet/mock_delegates.h
index 3696276..94686c3 100644
--- a/libweave/src/privet/mock_delegates.h
+++ b/libweave/src/privet/mock_delegates.h
@@ -68,19 +68,16 @@
   MOCK_CONST_METHOD0(GetPairingTypes, std::set<PairingType>());
   MOCK_CONST_METHOD0(GetCryptoTypes, std::set<CryptoType>());
   MOCK_CONST_METHOD1(IsValidPairingCode, bool(const std::string&));
-  MOCK_METHOD5(StartPairing,
-               bool(PairingType,
-                    CryptoType,
-                    std::string*,
-                    std::string*,
-                    chromeos::ErrorPtr*));
+  MOCK_METHOD5(
+      StartPairing,
+      bool(PairingType, CryptoType, std::string*, std::string*, ErrorPtr*));
   MOCK_METHOD5(ConfirmPairing,
                bool(const std::string&,
                     const std::string&,
                     std::string*,
                     std::string*,
-                    chromeos::ErrorPtr*));
-  MOCK_METHOD2(CancelPairing, bool(const std::string&, chromeos::ErrorPtr*));
+                    ErrorPtr*));
+  MOCK_METHOD2(CancelPairing, bool(const std::string&, ErrorPtr*));
 
   MockSecurityDelegate() {
     EXPECT_CALL(*this, CreateAccessToken(_, _))
@@ -120,9 +117,7 @@
   MOCK_CONST_METHOD0(GetConnectionState, const ConnectionState&());
   MOCK_CONST_METHOD0(GetSetupState, const SetupState&());
   MOCK_METHOD3(ConfigureCredentials,
-               bool(const std::string&,
-                    const std::string&,
-                    chromeos::ErrorPtr*));
+               bool(const std::string&, const std::string&, ErrorPtr*));
   MOCK_CONST_METHOD0(GetCurrentlyConnectedSsid, std::string());
   MOCK_CONST_METHOD0(GetHostedSsid, std::string());
   MOCK_CONST_METHOD0(GetTypes, std::set<WifiType>());
@@ -144,8 +139,8 @@
 
 class MockCloudDelegate : public CloudDelegate {
  public:
-  MOCK_CONST_METHOD2(GetModelId, bool(std::string*, chromeos::ErrorPtr*));
-  MOCK_CONST_METHOD2(GetName, bool(std::string*, chromeos::ErrorPtr*));
+  MOCK_CONST_METHOD2(GetModelId, bool(std::string*, ErrorPtr*));
+  MOCK_CONST_METHOD2(GetName, bool(std::string*, ErrorPtr*));
   MOCK_CONST_METHOD0(GetDescription, std::string());
   MOCK_CONST_METHOD0(GetLocation, std::string());
   MOCK_METHOD5(UpdateDeviceInfo,
@@ -160,10 +155,7 @@
   MOCK_CONST_METHOD0(GetAnonymousMaxScope, AuthScope());
   MOCK_CONST_METHOD0(GetConnectionState, const ConnectionState&());
   MOCK_CONST_METHOD0(GetSetupState, const SetupState&());
-  MOCK_METHOD3(Setup,
-               bool(const std::string&,
-                    const std::string&,
-                    chromeos::ErrorPtr*));
+  MOCK_METHOD3(Setup, bool(const std::string&, const std::string&, ErrorPtr*));
   MOCK_CONST_METHOD0(GetCloudId, std::string());
   MOCK_CONST_METHOD0(GetState, const base::DictionaryValue&());
   MOCK_CONST_METHOD0(GetCommandDef, const base::DictionaryValue&());
diff --git a/libweave/src/privet/privet_handler.cc b/libweave/src/privet/privet_handler.cc
index 9f22750..b83df36 100644
--- a/libweave/src/privet/privet_handler.cc
+++ b/libweave/src/privet/privet_handler.cc
@@ -158,8 +158,7 @@
   return SplitAtFirst(auth_header, " ", true).second;
 }
 
-std::unique_ptr<base::DictionaryValue> ErrorInfoToJson(
-    const chromeos::Error& error) {
+std::unique_ptr<base::DictionaryValue> ErrorInfoToJson(const Error& error) {
   std::unique_ptr<base::DictionaryValue> output{new base::DictionaryValue};
   output->SetString(kErrorMessageKey, error.GetMessage());
   output->SetString(kErrorCodeKey, error.GetCode());
@@ -167,13 +166,12 @@
 }
 
 // Creates JSON similar to GCD server error format.
-std::unique_ptr<base::DictionaryValue> ErrorToJson(
-    const chromeos::Error& error) {
+std::unique_ptr<base::DictionaryValue> ErrorToJson(const Error& error) {
   std::unique_ptr<base::DictionaryValue> output{ErrorInfoToJson(error)};
 
   // Optional debug information.
   std::unique_ptr<base::ListValue> errors{new base::ListValue};
-  for (const chromeos::Error* it = &error; it; it = it->GetInnerError()) {
+  for (const Error* it = &error; it; it = it->GetInnerError()) {
     std::unique_ptr<base::DictionaryValue> inner{ErrorInfoToJson(*it)};
     tracked_objects::Location location{it->GetLocation().function_name.c_str(),
                                        it->GetLocation().file_name.c_str(),
@@ -196,7 +194,7 @@
   parent->Set(kErrorKey, ErrorToJson(*state.error()).release());
 }
 
-void ReturnError(const chromeos::Error& error,
+void ReturnError(const Error& error,
                  const PrivetHandler::RequestCallback& callback) {
   int code = http::kInternalServerError;
   for (const auto& it : kReasonToCode) {
@@ -216,17 +214,17 @@
 }
 
 void OnCommandRequestFailed(const PrivetHandler::RequestCallback& callback,
-                            chromeos::Error* error) {
+                            Error* error) {
   if (error->HasError("gcd", "unknown_command")) {
-    chromeos::ErrorPtr new_error = error->Clone();
-    chromeos::Error::AddTo(&new_error, FROM_HERE, errors::kDomain,
-                           errors::kNotFound, "Unknown command ID");
+    ErrorPtr new_error = error->Clone();
+    Error::AddTo(&new_error, FROM_HERE, errors::kDomain, errors::kNotFound,
+                 "Unknown command ID");
     return ReturnError(*new_error, callback);
   }
   if (error->HasError("gcd", "access_denied")) {
-    chromeos::ErrorPtr new_error = error->Clone();
-    chromeos::Error::AddTo(&new_error, FROM_HERE, errors::kDomain,
-                           errors::kAccessDenied, error->GetMessage());
+    ErrorPtr new_error = error->Clone();
+    Error::AddTo(&new_error, FROM_HERE, errors::kDomain, errors::kAccessDenied,
+                 error->GetMessage());
     return ReturnError(*new_error, callback);
   }
   return ReturnError(*error, callback);
@@ -412,29 +410,29 @@
                                   const std::string& auth_header,
                                   const base::DictionaryValue* input,
                                   const RequestCallback& callback) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!input) {
-    chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                           errors::kInvalidFormat, "Malformed JSON");
+    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidFormat,
+                 "Malformed JSON");
     return ReturnError(*error, callback);
   }
   auto handler = handlers_.find(api);
   if (handler == handlers_.end()) {
-    chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                           errors::kNotFound, "Path not found");
+    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kNotFound,
+                 "Path not found");
     return ReturnError(*error, callback);
   }
   if (auth_header.empty()) {
-    chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                           errors::kMissingAuthorization,
-                           "Authorization header must not be empty");
+    Error::AddTo(&error, FROM_HERE, errors::kDomain,
+                 errors::kMissingAuthorization,
+                 "Authorization header must not be empty");
     return ReturnError(*error, callback);
   }
   std::string token = GetAuthTokenFromAuthHeader(auth_header);
   if (token.empty()) {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidAuthorization,
-        "Invalid authorization header: %s", auth_header.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidAuthorization,
+                       "Invalid authorization header: %s", auth_header.c_str());
     return ReturnError(*error, callback);
   }
   UserInfo user_info;
@@ -442,27 +440,27 @@
     base::Time time;
     user_info = security_->ParseAccessToken(token, &time);
     if (user_info.scope() == AuthScope::kNone) {
-      chromeos::Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                                   errors::kInvalidAuthorization,
-                                   "Invalid access token: %s", token.c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidAuthorization,
+                         "Invalid access token: %s", token.c_str());
       return ReturnError(*error, callback);
     }
     time += base::TimeDelta::FromSeconds(kAccessTokenExpirationSeconds);
     time +=
         base::TimeDelta::FromSeconds(kAccessTokenExpirationThresholdSeconds);
     if (time < base::Time::Now()) {
-      chromeos::Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                                   errors::kAuthorizationExpired,
-                                   "Token expired: %s", token.c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kAuthorizationExpired, "Token expired: %s",
+                         token.c_str());
       return ReturnError(*error, callback);
     }
   }
 
   if (handler->second.first > user_info.scope()) {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidAuthorizationScope,
-        "Scope '%s' does not allow '%s'",
-        EnumToString(user_info.scope()).c_str(), api.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidAuthorizationScope,
+                       "Scope '%s' does not allow '%s'",
+                       EnumToString(user_info.scope()).c_str(), api.c_str());
     return ReturnError(*error, callback);
   }
   (this->*handler->second.second)(*input, user_info, callback);
@@ -479,7 +477,7 @@
                                const RequestCallback& callback) {
   base::DictionaryValue output;
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   std::string name;
   std::string model_id;
@@ -525,7 +523,7 @@
 void PrivetHandler::HandlePairingStart(const base::DictionaryValue& input,
                                        const UserInfo& user_info,
                                        const RequestCallback& callback) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   std::string pairing_str;
   input.GetString(kPairingKey, &pairing_str);
@@ -536,18 +534,18 @@
   PairingType pairing;
   std::set<PairingType> modes = security_->GetPairingTypes();
   if (!StringToEnum(pairing_str, &pairing) || !ContainsKey(modes, pairing)) {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-        kInvalidParamValueFormat, kPairingKey, pairing_str.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidParams, kInvalidParamValueFormat,
+                       kPairingKey, pairing_str.c_str());
     return ReturnError(*error, callback);
   }
 
   CryptoType crypto;
   std::set<CryptoType> cryptos = security_->GetCryptoTypes();
   if (!StringToEnum(crypto_str, &crypto) || !ContainsKey(cryptos, crypto)) {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-        kInvalidParamValueFormat, kCryptoKey, crypto_str.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidParams, kInvalidParamValueFormat,
+                       kCryptoKey, crypto_str.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -573,7 +571,7 @@
 
   std::string fingerprint;
   std::string signature;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!security_->ConfirmPairing(id, commitment, &fingerprint, &signature,
                                  &error)) {
     return ReturnError(*error, callback);
@@ -591,7 +589,7 @@
   std::string id;
   input.GetString(kPairingSessionIdKey, &id);
 
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!security_->CancelPairing(id, &error))
     return ReturnError(*error, callback);
 
@@ -602,7 +600,7 @@
 void PrivetHandler::HandleAuth(const base::DictionaryValue& input,
                                const UserInfo& user_info,
                                const RequestCallback& callback) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   std::string auth_code_type;
   input.GetString(kAuthModeKey, &auth_code_type);
@@ -615,16 +613,16 @@
     max_auth_scope = GetAnonymousMaxScope(*cloud_, wifi_);
   } else if (auth_code_type == kAuthTypePairingValue) {
     if (!security_->IsValidPairingCode(auth_code)) {
-      chromeos::Error::AddToPrintf(
-          &error, FROM_HERE, errors::kDomain, errors::kInvalidAuthCode,
-          kInvalidParamValueFormat, kAuthCodeKey, auth_code.c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidAuthCode, kInvalidParamValueFormat,
+                         kAuthCodeKey, auth_code.c_str());
       return ReturnError(*error, callback);
     }
     max_auth_scope = AuthScope::kOwner;
   } else {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidAuthMode,
-        kInvalidParamValueFormat, kAuthModeKey, auth_code_type.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidAuthMode, kInvalidParamValueFormat,
+                       kAuthModeKey, auth_code_type.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -634,18 +632,16 @@
   AuthScope requested_auth_scope =
       AuthScopeFromString(requested_scope, max_auth_scope);
   if (requested_auth_scope == AuthScope::kNone) {
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidRequestedScope,
-        kInvalidParamValueFormat, kAuthRequestedScopeKey,
-        requested_scope.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidRequestedScope, kInvalidParamValueFormat,
+                       kAuthRequestedScopeKey, requested_scope.c_str());
     return ReturnError(*error, callback);
   }
 
   if (requested_auth_scope > max_auth_scope) {
-    chromeos::Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                                 errors::kAccessDenied,
-                                 "Scope '%s' is not allowed",
-                                 EnumToString(requested_auth_scope).c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kAccessDenied, "Scope '%s' is not allowed",
+                       EnumToString(requested_auth_scope).c_str());
     return ReturnError(*error, callback);
   }
 
@@ -664,7 +660,7 @@
                                      const UserInfo& user_info,
                                      const RequestCallback& callback) {
   std::string name;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   if (!cloud_->GetName(&name, &error))
     return ReturnError(*error, callback);
   input.GetString(kNameKey, &name);
@@ -683,16 +679,15 @@
   const base::DictionaryValue* wifi = nullptr;
   if (input.GetDictionary(kWifiKey, &wifi)) {
     if (!wifi_ || wifi_->GetTypes().empty()) {
-      chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                             errors::kSetupUnavailable,
-                             "WiFi setup unavailible");
+      Error::AddTo(&error, FROM_HERE, errors::kDomain,
+                   errors::kSetupUnavailable, "WiFi setup unavailible");
       return ReturnError(*error, callback);
     }
     wifi->GetString(kSetupStartSsidKey, &ssid);
     if (ssid.empty()) {
-      chromeos::Error::AddToPrintf(
-          &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-          kInvalidParamValueFormat, kSetupStartSsidKey, "");
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidParams, kInvalidParamValueFormat,
+                         kSetupStartSsidKey, "");
       return ReturnError(*error, callback);
     }
     wifi->GetString(kSetupStartPassKey, &passphrase);
@@ -702,9 +697,9 @@
   if (input.GetDictionary(kGcdKey, &registration)) {
     registration->GetString(kSetupStartTicketIdKey, &ticket);
     if (ticket.empty()) {
-      chromeos::Error::AddToPrintf(
-          &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-          kInvalidParamValueFormat, kSetupStartTicketIdKey, "");
+      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                         errors::kInvalidParams, kInvalidParamValueFormat,
+                         kSetupStartTicketIdKey, "");
       return ReturnError(*error, callback);
     }
     registration->GetString(kSetupStartUserKey, &user);
@@ -723,7 +718,7 @@
     const std::string& ticket,
     const std::string& user,
     const RequestCallback& callback) const {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
 
   if (!ssid.empty() && !wifi_->ConfigureCredentials(ssid, passphrase, &error))
     return ReturnError(*error, callback);
@@ -803,10 +798,10 @@
                                          const RequestCallback& callback) {
   std::string id;
   if (!input.GetString(kCommandsIdKey, &id)) {
-    chromeos::ErrorPtr error;
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-        kInvalidParamValueFormat, kCommandsIdKey, id.c_str());
+    ErrorPtr error;
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidParams, kInvalidParamValueFormat,
+                       kCommandsIdKey, id.c_str());
     return ReturnError(*error, callback);
   }
   cloud_->GetCommand(id, user_info,
@@ -827,10 +822,10 @@
                                          const RequestCallback& callback) {
   std::string id;
   if (!input.GetString(kCommandsIdKey, &id)) {
-    chromeos::ErrorPtr error;
-    chromeos::Error::AddToPrintf(
-        &error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
-        kInvalidParamValueFormat, kCommandsIdKey, id.c_str());
+    ErrorPtr error;
+    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
+                       errors::kInvalidParams, kInvalidParamValueFormat,
+                       kCommandsIdKey, id.c_str());
     return ReturnError(*error, callback);
   }
   cloud_->CancelCommand(id, user_info,
diff --git a/libweave/src/privet/privet_handler_unittest.cc b/libweave/src/privet/privet_handler_unittest.cc
index 240da55..2980115 100644
--- a/libweave/src/privet/privet_handler_unittest.cc
+++ b/libweave/src/privet/privet_handler_unittest.cc
@@ -159,9 +159,8 @@
     EXPECT_CALL(cloud_, GetConnectionState())
         .WillRepeatedly(ReturnRef(gcd_disabled_state_));
     auto set_error = [](const std::string&, const std::string&,
-                        chromeos::ErrorPtr* error) {
-      chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                             "setupUnavailable", "");
+                        ErrorPtr* error) {
+      Error::AddTo(error, FROM_HERE, errors::kDomain, "setupUnavailable", "");
     };
     EXPECT_CALL(cloud_, Setup(_, _, _))
         .WillRepeatedly(DoAll(Invoke(set_error), Return(false)));
@@ -479,8 +478,8 @@
 }
 
 TEST_F(PrivetHandlerSetupTest, StatusWifiError) {
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddTo(&error, FROM_HERE, "test", "invalidPassphrase", "");
+  ErrorPtr error;
+  Error::AddTo(&error, FROM_HERE, "test", "invalidPassphrase", "");
   wifi_.setup_state_ = SetupState{std::move(error)};
 
   const char kExpected[] = R"({
@@ -509,8 +508,8 @@
 }
 
 TEST_F(PrivetHandlerSetupTest, StatusGcdError) {
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddTo(&error, FROM_HERE, "test", "invalidTicket", "");
+  ErrorPtr error;
+  Error::AddTo(&error, FROM_HERE, "test", "invalidTicket", "");
   cloud_.setup_state_ = SetupState{std::move(error)};
 
   const char kExpected[] = R"({
@@ -569,9 +568,8 @@
       'passphrase': 'testPass'
     }
   })";
-  auto set_error = [](const std::string&, const std::string&,
-                      chromeos::ErrorPtr* error) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
+  auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
+    Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
   };
   EXPECT_CALL(wifi_, ConfigureCredentials(_, _, _))
       .WillOnce(DoAll(Invoke(set_error), Return(false)));
@@ -611,9 +609,8 @@
     }
   })";
 
-  auto set_error = [](const std::string&, const std::string&,
-                      chromeos::ErrorPtr* error) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
+  auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
+    Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
   };
   EXPECT_CALL(cloud_, Setup(_, _, _))
       .WillOnce(DoAll(Invoke(set_error), Return(false)));
@@ -675,8 +672,8 @@
   EXPECT_PRED2(IsEqualJson, "{'name':'test', 'id':'5'}",
                HandleRequest("/privet/v3/commands/status", kInput));
 
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
+  ErrorPtr error;
+  Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
   EXPECT_CALL(cloud_, GetCommand(_, _, _, _))
       .WillOnce(RunCallback<3>(error.get()));
 
@@ -694,8 +691,8 @@
   EXPECT_PRED2(IsEqualJson, kExpected,
                HandleRequest("/privet/v3/commands/cancel", "{'id': '8'}"));
 
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
+  ErrorPtr error;
+  Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
   EXPECT_CALL(cloud_, CancelCommand(_, _, _, _))
       .WillOnce(RunCallback<3>(error.get()));
 
diff --git a/libweave/src/privet/privet_types.h b/libweave/src/privet/privet_types.h
index 7626400..b46e5b6 100644
--- a/libweave/src/privet/privet_types.h
+++ b/libweave/src/privet/privet_types.h
@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 namespace privet {
@@ -54,7 +54,7 @@
   };
 
   explicit ConnectionState(Status status) : status_(status) {}
-  explicit ConnectionState(chromeos::ErrorPtr error)
+  explicit ConnectionState(ErrorPtr error)
       : status_(kOffline), error_(std::move(error)) {}
 
   Status status() const {
@@ -68,11 +68,11 @@
     return status_ == status;
   }
 
-  const chromeos::Error* error() const { return error_.get(); }
+  const Error* error() const { return error_.get(); }
 
  private:
   Status status_;
-  chromeos::ErrorPtr error_;
+  ErrorPtr error_;
 };
 
 class SetupState final {
@@ -84,7 +84,7 @@
   };
 
   explicit SetupState(Status status) : status_(status) {}
-  explicit SetupState(chromeos::ErrorPtr error)
+  explicit SetupState(ErrorPtr error)
       : status_(kNone), error_(std::move(error)) {}
 
   Status status() const {
@@ -98,11 +98,11 @@
     return status_ == status;
   }
 
-  const chromeos::Error* error() const { return error_.get(); }
+  const Error* error() const { return error_.get(); }
 
  private:
   Status status_;
-  chromeos::ErrorPtr error_;
+  ErrorPtr error_;
 };
 
 }  // namespace privet
diff --git a/libweave/src/privet/publisher.cc b/libweave/src/privet/publisher.cc
index b9f7080..9daed21 100644
--- a/libweave/src/privet/publisher.cc
+++ b/libweave/src/privet/publisher.cc
@@ -6,7 +6,7 @@
 
 #include <map>
 
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/mdns.h>
 
 #include "libweave/src/privet/cloud_delegate.h"
diff --git a/libweave/src/privet/security_delegate.h b/libweave/src/privet/security_delegate.h
index e168a87..4dfd05c 100644
--- a/libweave/src/privet/security_delegate.h
+++ b/libweave/src/privet/security_delegate.h
@@ -44,16 +44,16 @@
                             CryptoType crypto,
                             std::string* session_id,
                             std::string* device_commitment,
-                            chromeos::ErrorPtr* error) = 0;
+                            ErrorPtr* error) = 0;
 
   virtual bool ConfirmPairing(const std::string& session_id,
                               const std::string& client_commitment,
                               std::string* fingerprint,
                               std::string* signature,
-                              chromeos::ErrorPtr* error) = 0;
+                              ErrorPtr* error) = 0;
 
   virtual bool CancelPairing(const std::string& session_id,
-                             chromeos::ErrorPtr* error) = 0;
+                             ErrorPtr* error) = 0;
 };
 
 }  // namespace privet
diff --git a/libweave/src/privet/security_manager.cc b/libweave/src/privet/security_manager.cc
index 1343a7c..8f90cc4 100644
--- a/libweave/src/privet/security_manager.cc
+++ b/libweave/src/privet/security_manager.cc
@@ -87,15 +87,13 @@
   // SecurityManager::KeyExchanger methods.
   const std::string& GetMessage() override { return spake_.GetNextMessage(); }
 
-  bool ProcessMessage(const std::string& message,
-                      chromeos::ErrorPtr* error) override {
+  bool ProcessMessage(const std::string& message, ErrorPtr* error) override {
     switch (spake_.ProcessMessage(message)) {
       case crypto::P224EncryptedKeyExchange::kResultPending:
         return true;
       case crypto::P224EncryptedKeyExchange::kResultFailed:
-        chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                               errors::kInvalidClientCommitment,
-                               spake_.error());
+        Error::AddTo(error, FROM_HERE, errors::kDomain,
+                     errors::kInvalidClientCommitment, spake_.error());
         return false;
       default:
         LOG(FATAL) << "SecurityManager uses only one round trip";
@@ -120,8 +118,7 @@
   // SecurityManager::KeyExchanger methods.
   const std::string& GetMessage() override { return password_; }
 
-  bool ProcessMessage(const std::string& message,
-                      chromeos::ErrorPtr* error) override {
+  bool ProcessMessage(const std::string& message, ErrorPtr* error) override {
     return true;
   }
 
@@ -214,15 +211,14 @@
                                    CryptoType crypto,
                                    std::string* session_id,
                                    std::string* device_commitment,
-                                   chromeos::ErrorPtr* error) {
+                                   ErrorPtr* error) {
   if (!CheckIfPairingAllowed(error))
     return false;
 
   if (std::find(pairing_modes_.begin(), pairing_modes_.end(), mode) ==
       pairing_modes_.end()) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                           errors::kInvalidParams,
-                           "Pairing mode is not enabled");
+    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+                 "Pairing mode is not enabled");
     return false;
   }
 
@@ -235,9 +231,8 @@
         embedded_code_ = LoadEmbeddedCode(embedded_code_path_);
 
       if (embedded_code_.empty()) {  // File is not created yet.
-        chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                               errors::kDeviceBusy,
-                               "Embedded code is not ready");
+        Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kDeviceBusy,
+                     "Embedded code is not ready");
         return false;
       }
 
@@ -252,9 +247,8 @@
       code = base::StringPrintf("%04i", base::RandInt(0, 9999));
       break;
     default:
-      chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                             errors::kInvalidParams,
-                             "Unsupported pairing mode");
+      Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+                   "Unsupported pairing mode");
       return false;
   }
 
@@ -270,8 +264,8 @@
       }
     // Fall through...
     default:
-      chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                             errors::kInvalidParams, "Unsupported crypto");
+      Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+                   "Unsupported crypto");
       return false;
   }
 
@@ -310,12 +304,12 @@
                                      const std::string& client_commitment,
                                      std::string* fingerprint,
                                      std::string* signature,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   auto session = pending_sessions_.find(session_id);
   if (session == pending_sessions_.end()) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, errors::kDomain, errors::kUnknownSession,
-        "Unknown session id: '%s'", session_id.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
+                       errors::kUnknownSession, "Unknown session id: '%s'",
+                       session_id.c_str());
     return false;
   }
   CHECK(!certificate_fingerprint_.empty());
@@ -323,7 +317,7 @@
   std::vector<uint8_t> commitment;
   if (!Base64Decode(client_commitment, &commitment)) {
     ClosePendingSession(session_id);
-    chromeos::Error::AddToPrintf(
+    Error::AddToPrintf(
         error, FROM_HERE, errors::kDomain, errors::kInvalidFormat,
         "Invalid commitment string: '%s'", client_commitment.c_str());
     return false;
@@ -332,9 +326,8 @@
   if (!session->second->ProcessMessage(
           std::string(commitment.begin(), commitment.end()), error)) {
     ClosePendingSession(session_id);
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                           errors::kCommitmentMismatch,
-                           "Pairing code or crypto implementation mismatch");
+    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kCommitmentMismatch,
+                 "Pairing code or crypto implementation mismatch");
     return false;
   }
 
@@ -356,7 +349,7 @@
 }
 
 bool SecurityManager::CancelPairing(const std::string& session_id,
-                                    chromeos::ErrorPtr* error) {
+                                    ErrorPtr* error) {
   bool confirmed = CloseConfirmedSession(session_id);
   bool pending = ClosePendingSession(session_id);
   if (pending) {
@@ -366,9 +359,8 @@
   CHECK(!confirmed || !pending);
   if (confirmed || pending)
     return true;
-  chromeos::Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                               errors::kUnknownSession,
-                               "Unknown session id: '%s'", session_id.c_str());
+  Error::AddToPrintf(error, FROM_HERE, errors::kDomain, errors::kUnknownSession,
+                     "Unknown session id: '%s'", session_id.c_str());
   return false;
 }
 
@@ -380,13 +372,13 @@
   on_end_ = on_end;
 }
 
-bool SecurityManager::CheckIfPairingAllowed(chromeos::ErrorPtr* error) {
+bool SecurityManager::CheckIfPairingAllowed(ErrorPtr* error) {
   if (is_security_disabled_)
     return true;
 
   if (block_pairing_until_ > base::Time::Now()) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
-                           errors::kDeviceBusy, "Too many pairing attempts");
+    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kDeviceBusy,
+                 "Too many pairing attempts");
     return false;
   }
 
diff --git a/libweave/src/privet/security_manager.h b/libweave/src/privet/security_manager.h
index 3beacb6..f0a6de4 100644
--- a/libweave/src/privet/security_manager.h
+++ b/libweave/src/privet/security_manager.h
@@ -14,7 +14,7 @@
 #include <base/callback.h>
 #include <base/files/file_path.h>
 #include <base/memory/weak_ptr.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/privet/security_delegate.h"
 
@@ -43,7 +43,7 @@
 
     virtual const std::string& GetMessage() = 0;
     virtual bool ProcessMessage(const std::string& message,
-                                chromeos::ErrorPtr* error) = 0;
+                                ErrorPtr* error) = 0;
     virtual const std::string& GetKey() const = 0;
   };
 
@@ -66,15 +66,14 @@
                     CryptoType crypto,
                     std::string* session_id,
                     std::string* device_commitment,
-                    chromeos::ErrorPtr* error) override;
+                    ErrorPtr* error) override;
 
   bool ConfirmPairing(const std::string& session_id,
                       const std::string& client_commitment,
                       std::string* fingerprint,
                       std::string* signature,
-                      chromeos::ErrorPtr* error) override;
-  bool CancelPairing(const std::string& session_id,
-                     chromeos::ErrorPtr* error) override;
+                      ErrorPtr* error) override;
+  bool CancelPairing(const std::string& session_id, ErrorPtr* error) override;
 
   void RegisterPairingListeners(const PairingStartListener& on_start,
                                 const PairingEndListener& on_end);
@@ -86,7 +85,7 @@
  private:
   FRIEND_TEST_ALL_PREFIXES(SecurityManagerTest, ThrottlePairing);
   // Allows limited number of new sessions without successful authorization.
-  bool CheckIfPairingAllowed(chromeos::ErrorPtr* error);
+  bool CheckIfPairingAllowed(ErrorPtr* error);
   bool ClosePendingSession(const std::string& session_id);
   bool CloseConfirmedSession(const std::string& session_id);
 
diff --git a/libweave/src/privet/security_manager_unittest.cc b/libweave/src/privet/security_manager_unittest.cc
index 0d13cfe..8ce0ba9 100644
--- a/libweave/src/privet/security_manager_unittest.cc
+++ b/libweave/src/privet/security_manager_unittest.cc
@@ -177,7 +177,7 @@
 TEST_F(SecurityManagerTest, PairingNoSession) {
   std::string fingerprint;
   std::string signature;
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       security_.ConfirmPairing("123", "345", &fingerprint, &signature, &error));
   EXPECT_EQ("unknownSession", error->GetCode());
@@ -251,7 +251,7 @@
   auto pair = [this]() {
     std::string session_id;
     std::string device_commitment;
-    chromeos::ErrorPtr error;
+    ErrorPtr error;
     bool result = security_.StartPairing(PairingType::kEmbeddedCode,
                                          CryptoType::kSpake_p224, &session_id,
                                          &device_commitment, &error);
@@ -306,7 +306,7 @@
   std::string session_id;
   std::string device_commitment;
   base::DeleteFile(embedded_code_path_, false);
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(security_.StartPairing(PairingType::kEmbeddedCode,
                                       CryptoType::kSpake_p224, &session_id,
                                       &device_commitment, &error));
diff --git a/libweave/src/privet/wifi_bootstrap_manager.cc b/libweave/src/privet/wifi_bootstrap_manager.cc
index 4a32fdc..d5f7916 100644
--- a/libweave/src/privet/wifi_bootstrap_manager.cc
+++ b/libweave/src/privet/wifi_bootstrap_manager.cc
@@ -178,7 +178,7 @@
 
 bool WifiBootstrapManager::ConfigureCredentials(const std::string& ssid,
                                                 const std::string& passphrase,
-                                                chromeos::ErrorPtr* error) {
+                                                ErrorPtr* error) {
   setup_state_ = SetupState{SetupState::kInProgress};
   // TODO(vitalybuka): Find more reliable way to finish request or move delay
   // into PrivetHandler as it's very HTTP specific.
@@ -223,10 +223,9 @@
 
 void WifiBootstrapManager::OnConnectTimeout() {
   VLOG(1) << "Wifi timed out while connecting";
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                         errors::kInvalidState,
-                         "Failed to connect to provided network");
+  ErrorPtr error;
+  Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+               "Failed to connect to provided network");
   setup_state_ = SetupState{std::move(error)};
   StartBootstrapping();
 }
@@ -271,9 +270,9 @@
       return;
     case NetworkState::kFailure: {
       // TODO(wiley) Pull error information from somewhere.
-      chromeos::ErrorPtr error;
-      chromeos::Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                             errors::kInvalidState, "Unknown WiFi error");
+      ErrorPtr error;
+      Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+                   "Unknown WiFi error");
       connection_state_ = ConnectionState{std::move(error)};
       return;
     }
@@ -284,10 +283,10 @@
       connection_state_ = ConnectionState{ConnectionState::kOnline};
       return;
   }
-  chromeos::ErrorPtr error;
-  chromeos::Error::AddToPrintf(
-      &error, FROM_HERE, errors::kDomain, errors::kInvalidState,
-      "Unknown network state: %s", EnumToString(service_state).c_str());
+  ErrorPtr error;
+  Error::AddToPrintf(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+                     "Unknown network state: %s",
+                     EnumToString(service_state).c_str());
   connection_state_ = ConnectionState{std::move(error)};
 }
 
diff --git a/libweave/src/privet/wifi_bootstrap_manager.h b/libweave/src/privet/wifi_bootstrap_manager.h
index aa47839..c6f97d7 100644
--- a/libweave/src/privet/wifi_bootstrap_manager.h
+++ b/libweave/src/privet/wifi_bootstrap_manager.h
@@ -51,7 +51,7 @@
   const SetupState& GetSetupState() const override;
   bool ConfigureCredentials(const std::string& ssid,
                             const std::string& passphrase,
-                            chromeos::ErrorPtr* error) override;
+                            ErrorPtr* error) override;
   std::string GetCurrentlyConnectedSsid() const override;
   std::string GetHostedSsid() const override;
   std::set<WifiType> GetTypes() const override;
diff --git a/libweave/src/privet/wifi_delegate.h b/libweave/src/privet/wifi_delegate.h
index ae71849..3a44dc4 100644
--- a/libweave/src/privet/wifi_delegate.h
+++ b/libweave/src/privet/wifi_delegate.h
@@ -32,7 +32,7 @@
   // Final setup state can be retrieved with GetSetupState().
   virtual bool ConfigureCredentials(const std::string& ssid,
                                     const std::string& password,
-                                    chromeos::ErrorPtr* error) = 0;
+                                    ErrorPtr* error) = 0;
 
   // Returns SSID of the currently configured WiFi network. Empty string, if
   // WiFi has not been configured yet.
diff --git a/libweave/src/states/state_manager.cc b/libweave/src/states/state_manager.cc
index 6f2646b..48dbc74 100644
--- a/libweave/src/states/state_manager.cc
+++ b/libweave/src/states/state_manager.cc
@@ -88,7 +88,7 @@
 }
 
 bool StateManager::SetProperties(const base::DictionaryValue& property_set,
-                                 chromeos::ErrorPtr* error) {
+                                 ErrorPtr* error) {
   base::Time timestamp = base::Time::Now();
   bool all_success = true;
   for (base::DictionaryValue::Iterator it(property_set); !it.IsAtEnd();
@@ -107,30 +107,30 @@
 bool StateManager::SetPropertyValue(const std::string& full_property_name,
                                     const base::Value& value,
                                     const base::Time& timestamp,
-                                    chromeos::ErrorPtr* error) {
+                                    ErrorPtr* error) {
   auto parts = SplitAtFirst(full_property_name, ".", true);
   const std::string& package_name = parts.first;
   const std::string& property_name = parts.second;
   const bool split = (full_property_name.find(".") != std::string::npos);
 
   if (full_property_name.empty() || (split && property_name.empty())) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::state::kDomain,
-                           errors::state::kPropertyNameMissing,
-                           "Property name is missing");
+    Error::AddTo(error, FROM_HERE, errors::state::kDomain,
+                 errors::state::kPropertyNameMissing,
+                 "Property name is missing");
     return false;
   }
   if (!split || package_name.empty()) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::state::kDomain,
-                           errors::state::kPackageNameMissing,
-                           "Package name is missing in the property name");
+    Error::AddTo(error, FROM_HERE, errors::state::kDomain,
+                 errors::state::kPackageNameMissing,
+                 "Package name is missing in the property name");
     return false;
   }
   StatePackage* package = FindPackage(package_name);
   if (package == nullptr) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                 errors::state::kPropertyNotDefined,
-                                 "Unknown state property package '%s'",
-                                 package_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
+                       errors::state::kPropertyNotDefined,
+                       "Unknown state property package '%s'",
+                       package_name.c_str());
     return false;
   }
   if (!package->SetPropertyValue(property_name, value, error))
@@ -154,22 +154,21 @@
 
 bool StateManager::LoadStateDefinition(const base::DictionaryValue& json,
                                        const std::string& category,
-                                       chromeos::ErrorPtr* error) {
+                                       ErrorPtr* error) {
   base::DictionaryValue::Iterator iter(json);
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain,
-                             kInvalidPackageError,
-                             "State package name is empty");
+      Error::AddTo(error, FROM_HERE, kErrorDomain, kInvalidPackageError,
+                   "State package name is empty");
       return false;
     }
     const base::DictionaryValue* package_dict = nullptr;
     if (!iter.value().GetAsDictionary(&package_dict)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                   errors::json::kObjectExpected,
-                                   "State package '%s' must be an object",
-                                   package_name.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                         errors::json::kObjectExpected,
+                         "State package '%s' must be an object",
+                         package_name.c_str());
       return false;
     }
     StatePackage* package = FindOrCreatePackage(package_name);
@@ -185,70 +184,67 @@
 }
 
 bool StateManager::LoadStateDefinition(const base::FilePath& json_file_path,
-                                       chromeos::ErrorPtr* error) {
+                                       ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> json =
       LoadJsonDict(json_file_path, error);
   if (!json)
     return false;
   std::string category = json_file_path.BaseName().RemoveExtension().value();
   if (category == kDefaultCategory) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain,
-                                 kInvalidCategoryError,
-                                 "Invalid state category specified in '%s'",
-                                 json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kInvalidCategoryError,
+                       "Invalid state category specified in '%s'",
+                       json_file_path.value().c_str());
     return false;
   }
 
   if (!LoadStateDefinition(*json, category, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                                 "Failed to load file '%s'",
-                                 json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                       "Failed to load file '%s'",
+                       json_file_path.value().c_str());
     return false;
   }
   return true;
 }
 
 bool StateManager::LoadBaseStateDefinition(const base::FilePath& json_file_path,
-                                           chromeos::ErrorPtr* error) {
+                                           ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> json =
       LoadJsonDict(json_file_path, error);
   if (!json)
     return false;
   if (!LoadStateDefinition(*json, kDefaultCategory, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                                 "Failed to load file '%s'",
-                                 json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                       "Failed to load file '%s'",
+                       json_file_path.value().c_str());
     return false;
   }
   return true;
 }
 
 bool StateManager::LoadStateDefaults(const base::DictionaryValue& json,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   base::DictionaryValue::Iterator iter(json);
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain,
-                             kInvalidPackageError,
-                             "State package name is empty");
+      Error::AddTo(error, FROM_HERE, kErrorDomain, kInvalidPackageError,
+                   "State package name is empty");
       return false;
     }
     const base::DictionaryValue* package_dict = nullptr;
     if (!iter.value().GetAsDictionary(&package_dict)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                   errors::json::kObjectExpected,
-                                   "State package '%s' must be an object",
-                                   package_name.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                         errors::json::kObjectExpected,
+                         "State package '%s' must be an object",
+                         package_name.c_str());
       return false;
     }
     StatePackage* package = FindPackage(package_name);
     if (package == nullptr) {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, errors::json::kDomain,
-          errors::json::kObjectExpected,
-          "Providing values for undefined state package '%s'",
-          package_name.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                         errors::json::kObjectExpected,
+                         "Providing values for undefined state package '%s'",
+                         package_name.c_str());
       return false;
     }
     if (!package->AddValuesFromJson(package_dict, error))
@@ -259,15 +255,15 @@
 }
 
 bool StateManager::LoadStateDefaults(const base::FilePath& json_file_path,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> json =
       LoadJsonDict(json_file_path, error);
   if (!json)
     return false;
   if (!LoadStateDefaults(*json, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                                 "Failed to load file '%s'",
-                                 json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                       "Failed to load file '%s'",
+                       json_file_path.value().c_str());
     return false;
   }
   return true;
diff --git a/libweave/src/states/state_manager.h b/libweave/src/states/state_manager.h
index 30825bd..1668bb2 100644
--- a/libweave/src/states/state_manager.h
+++ b/libweave/src/states/state_manager.h
@@ -14,7 +14,7 @@
 
 #include <base/callback.h>
 #include <base/macros.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 #include <weave/state.h>
 
 #include "libweave/src/states/state_change_queue_interface.h"
@@ -39,7 +39,7 @@
   // State overrides.
   void AddOnChangedCallback(const base::Closure& callback) override;
   bool SetProperties(const base::DictionaryValue& property_set,
-                     chromeos::ErrorPtr* error) override;
+                     ErrorPtr* error) override;
   std::unique_ptr<base::DictionaryValue> GetStateValuesAsJson() const override;
 
   // Initializes the state manager and load device state fragments.
@@ -73,33 +73,31 @@
   bool SetPropertyValue(const std::string& full_property_name,
                         const base::Value& value,
                         const base::Time& timestamp,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 
   // Loads a device state fragment from a JSON object. |category| represents
   // a device daemon providing the state fragment or empty string for the
   // base state fragment.
   bool LoadStateDefinition(const base::DictionaryValue& json,
                            const std::string& category,
-                           chromeos::ErrorPtr* error);
+                           ErrorPtr* error);
 
   // Loads a device state fragment JSON file. The file name (without extension)
   // is used as the state fragment category.
   bool LoadStateDefinition(const base::FilePath& json_file_path,
-                           chromeos::ErrorPtr* error);
+                           ErrorPtr* error);
 
   // Loads the base device state fragment JSON file. This state fragment
   // defines the standard state properties from the 'base' package as defined
   // by GCD specification.
   bool LoadBaseStateDefinition(const base::FilePath& json_file_path,
-                               chromeos::ErrorPtr* error);
+                               ErrorPtr* error);
 
   // Loads state default values from JSON object.
-  bool LoadStateDefaults(const base::DictionaryValue& json,
-                         chromeos::ErrorPtr* error);
+  bool LoadStateDefaults(const base::DictionaryValue& json, ErrorPtr* error);
 
   // Loads state default values from JSON file.
-  bool LoadStateDefaults(const base::FilePath& json_file_path,
-                         chromeos::ErrorPtr* error);
+  bool LoadStateDefaults(const base::FilePath& json_file_path, ErrorPtr* error);
 
   // Finds a package by its name. Returns nullptr if not found.
   StatePackage* FindPackage(const std::string& package_name);
diff --git a/libweave/src/states/state_manager_unittest.cc b/libweave/src/states/state_manager_unittest.cc
index 95f85a5..cf3d904 100644
--- a/libweave/src/states/state_manager_unittest.cc
+++ b/libweave/src/states/state_manager_unittest.cc
@@ -69,13 +69,13 @@
 
   void LoadStateDefinition(const base::DictionaryValue* json,
                            const std::string& category,
-                           chromeos::ErrorPtr* error) {
+                           ErrorPtr* error) {
     ASSERT_TRUE(mgr_->LoadStateDefinition(*json, category, error));
   }
 
   bool SetPropertyValue(const std::string& name,
                         const base::Value& value,
-                        chromeos::ErrorPtr* error) {
+                        ErrorPtr* error) {
     return mgr_->SetPropertyValue(name, value, timestamp_, error);
   }
 
@@ -154,14 +154,14 @@
 }
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_NoName) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(SetPropertyValue("", base::FundamentalValue{0}, &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNameMissing, error->GetCode());
 }
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_NoPackage) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       SetPropertyValue("state_property", base::FundamentalValue{0}, &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
@@ -169,7 +169,7 @@
 }
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_UnknownPackage) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       SetPropertyValue("power.level", base::FundamentalValue{0}, &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
@@ -177,7 +177,7 @@
 }
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_UnknownProperty) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       SetPropertyValue("base.level", base::FundamentalValue{0}, &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
diff --git a/libweave/src/states/state_package.cc b/libweave/src/states/state_package.cc
index e20d267..2a9ce95 100644
--- a/libweave/src/states/state_package.cc
+++ b/libweave/src/states/state_package.cc
@@ -18,7 +18,7 @@
 }
 
 bool StatePackage::AddSchemaFromJson(const base::DictionaryValue* json,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   ObjectSchema schema;
   if (!schema.FromJson(json, nullptr, error))
     return false;
@@ -26,10 +26,10 @@
   // Scan first to make sure we have no property redefinitions.
   for (const auto& pair : schema.GetProps()) {
     if (types_.GetProp(pair.first)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                   errors::state::kPropertyRedefinition,
-                                   "State property '%s.%s' is already defined",
-                                   name_.c_str(), pair.first.c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
+                         errors::state::kPropertyRedefinition,
+                         "State property '%s.%s' is already defined",
+                         name_.c_str(), pair.first.c_str());
       return false;
     }
   }
@@ -45,7 +45,7 @@
 }
 
 bool StatePackage::AddValuesFromJson(const base::DictionaryValue* json,
-                                     chromeos::ErrorPtr* error) {
+                                     ErrorPtr* error) {
   for (base::DictionaryValue::Iterator it(*json); !it.IsAtEnd(); it.Advance()) {
     if (!SetPropertyValue(it.key(), it.value(), error))
       return false;
@@ -65,13 +65,13 @@
 
 std::unique_ptr<base::Value> StatePackage::GetPropertyValue(
     const std::string& property_name,
-    chromeos::ErrorPtr* error) const {
+    ErrorPtr* error) const {
   auto it = values_.find(property_name);
   if (it == values_.end()) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                 errors::state::kPropertyNotDefined,
-                                 "State property '%s.%s' is not defined",
-                                 name_.c_str(), property_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
+                       errors::state::kPropertyNotDefined,
+                       "State property '%s.%s' is not defined", name_.c_str(),
+                       property_name.c_str());
     return nullptr;
   }
 
@@ -80,13 +80,13 @@
 
 bool StatePackage::SetPropertyValue(const std::string& property_name,
                                     const base::Value& value,
-                                    chromeos::ErrorPtr* error) {
+                                    ErrorPtr* error) {
   auto it = values_.find(property_name);
   if (it == values_.end()) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                 errors::state::kPropertyNotDefined,
-                                 "State property '%s.%s' is not defined",
-                                 name_.c_str(), property_name.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
+                       errors::state::kPropertyNotDefined,
+                       "State property '%s.%s' is not defined", name_.c_str(),
+                       property_name.c_str());
     return false;
   }
   auto new_value = it->second->GetPropType()->CreatePropValue(value, error);
diff --git a/libweave/src/states/state_package.h b/libweave/src/states/state_package.h
index 0ee7cc9..70e4df2 100644
--- a/libweave/src/states/state_package.h
+++ b/libweave/src/states/state_package.h
@@ -10,7 +10,7 @@
 #include <string>
 
 #include <base/macros.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 #include "libweave/src/commands/object_schema.h"
 #include "libweave/src/commands/prop_values.h"
@@ -30,13 +30,11 @@
 
   // Loads state property definitions from a JSON object and adds them
   // to the current package.
-  bool AddSchemaFromJson(const base::DictionaryValue* json,
-                         chromeos::ErrorPtr* error);
+  bool AddSchemaFromJson(const base::DictionaryValue* json, ErrorPtr* error);
   // Loads a set of state property values from a JSON object and assigns them
   // to existing properties.  A property must be defined prior to loading its
   // value.  We use this when we load default values during buffet startup.
-  bool AddValuesFromJson(const base::DictionaryValue* json,
-                         chromeos::ErrorPtr* error);
+  bool AddValuesFromJson(const base::DictionaryValue* json, ErrorPtr* error);
 
   // Returns a set of state properties and their values as a JSON object.
   // After being aggregated across multiple packages, this becomes the device
@@ -57,12 +55,12 @@
   // include the package name as part of the property name.
   std::unique_ptr<base::Value> GetPropertyValue(
       const std::string& property_name,
-      chromeos::ErrorPtr* error) const;
+      ErrorPtr* error) const;
   // Sets the value for a specific state property. |property_name| must not
   // include the package name as part of the property name.
   bool SetPropertyValue(const std::string& property_name,
                         const base::Value& value,
-                        chromeos::ErrorPtr* error);
+                        ErrorPtr* error);
 
   std::shared_ptr<const PropValue> GetProperty(
       const std::string& property_name) const {
diff --git a/libweave/src/states/state_package_unittest.cc b/libweave/src/states/state_package_unittest.cc
index d6978c0..45914bc 100644
--- a/libweave/src/states/state_package_unittest.cc
+++ b/libweave/src/states/state_package_unittest.cc
@@ -213,7 +213,7 @@
 
 TEST_F(StatePackageTest, AddSchemaFromJson_Error_Redefined) {
   auto dict = CreateDictionaryValue("{'color':['white', 'blue', 'red']}");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(package_->AddSchemaFromJson(dict.get(), &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyRedefinition, error->GetCode());
@@ -221,7 +221,7 @@
 
 TEST_F(StatePackageTest, AddValuesFromJson_Error_Undefined) {
   auto dict = CreateDictionaryValue("{'brightness':'medium'}");
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_FALSE(package_->AddValuesFromJson(dict.get(), &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
@@ -236,7 +236,7 @@
 }
 
 TEST_F(StatePackageTest, GetPropertyValue_Unknown) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   EXPECT_EQ(nullptr, package_->GetPropertyValue("volume", &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
@@ -275,7 +275,7 @@
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_TypeMismatch) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       package_->SetPropertyValue("color", base::FundamentalValue{12}, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -289,7 +289,7 @@
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_OutOfRange) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(
       package_->SetPropertyValue("iso", base::FundamentalValue{150}, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -297,31 +297,31 @@
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_TypeMismatch) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(package_->SetPropertyValue(
       "direction",
       *CreateDictionaryValue("{'altitude': 45.0, 'azimuth': '15'}"), &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
   EXPECT_EQ(errors::commands::kInvalidPropValue, error->GetCode());
-  const chromeos::Error* inner = error->GetInnerError();
+  const Error* inner = error->GetInnerError();
   EXPECT_EQ(errors::commands::kDomain, inner->GetDomain());
   EXPECT_EQ(errors::commands::kTypeMismatch, inner->GetCode());
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_OutOfRange) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(package_->SetPropertyValue(
       "direction",
       *CreateDictionaryValue("{'altitude': 100.0, 'azimuth': 290.0}"), &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
   EXPECT_EQ(errors::commands::kInvalidPropValue, error->GetCode());
-  const chromeos::Error* inner = error->GetInnerError();
+  const Error* inner = error->GetInnerError();
   EXPECT_EQ(errors::commands::kDomain, inner->GetDomain());
   EXPECT_EQ(errors::commands::kOutOfRange, inner->GetCode());
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_UnknownProperty) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(package_->SetPropertyValue(
       "direction", *CreateDictionaryValue(
                        "{'altitude': 10.0, 'azimuth': 20.0, 'spin': 30.0}"),
@@ -340,7 +340,7 @@
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_MissingProperty) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(package_->SetPropertyValue(
       "direction", *CreateDictionaryValue("{'altitude': 10.0}"), &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -348,7 +348,7 @@
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_Unknown) {
-  chromeos::ErrorPtr error;
+  ErrorPtr error;
   ASSERT_FALSE(package_->SetPropertyValue("volume", base::FundamentalValue{100},
                                           &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
diff --git a/libweave/src/utils.cc b/libweave/src/utils.cc
index ea31476..dd62f88 100644
--- a/libweave/src/utils.cc
+++ b/libweave/src/utils.cc
@@ -33,12 +33,12 @@
 
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const base::FilePath& json_file_path,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   std::string json_string;
   if (!base::ReadFileToString(json_file_path, &json_string)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                                 "Failed to read file '%s'",
-                                 json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                       "Failed to read file '%s'",
+                       json_file_path.value().c_str());
     return {};
   }
   return LoadJsonDict(json_string, error);
@@ -46,25 +46,25 @@
 
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const std::string& json_string,
-    chromeos::ErrorPtr* error) {
+    ErrorPtr* error) {
   std::unique_ptr<base::DictionaryValue> result;
   std::string error_message;
   auto value = base::JSONReader::ReadAndReturnError(
       json_string, base::JSON_PARSE_RFC, nullptr, &error_message);
   if (!value) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                 errors::json::kParseError,
-                                 "Error parsing JSON string '%s' (%zu): %s",
-                                 LimitString(json_string, kMaxStrLen).c_str(),
-                                 json_string.size(), error_message.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                       errors::json::kParseError,
+                       "Error parsing JSON string '%s' (%zu): %s",
+                       LimitString(json_string, kMaxStrLen).c_str(),
+                       json_string.size(), error_message.c_str());
     return result;
   }
   base::DictionaryValue* dict_value = nullptr;
   if (!value->GetAsDictionary(&dict_value)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
-                                 errors::json::kObjectExpected,
-                                 "JSON string '%s' is not a JSON object",
-                                 LimitString(json_string, kMaxStrLen).c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::json::kDomain,
+                       errors::json::kObjectExpected,
+                       "JSON string '%s' is not a JSON object",
+                       LimitString(json_string, kMaxStrLen).c_str());
     return result;
   } else {
     // |value| is now owned by |dict_value|.
diff --git a/libweave/src/utils.h b/libweave/src/utils.h
index a06ad7c..7ef4fa1 100644
--- a/libweave/src/utils.h
+++ b/libweave/src/utils.h
@@ -10,7 +10,7 @@
 
 #include <base/values.h>
 #include <base/files/file_path.h>
-#include <chromeos/errors/error.h>
+#include <weave/error.h>
 
 namespace weave {
 
@@ -31,12 +31,12 @@
 // in error details in |error|.
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const base::FilePath& json_file_path,
-    chromeos::ErrorPtr* error);
+    ErrorPtr* error);
 
 // Helper function to load a JSON dictionary from a string.
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const std::string& json_string,
-    chromeos::ErrorPtr* error);
+    ErrorPtr* error);
 
 }  // namespace weave