diff --git a/src/privet/auth_manager.cc b/src/privet/auth_manager.cc
index 8373a7e..0753a2b 100644
--- a/src/privet/auth_manager.cc
+++ b/src/privet/auth_manager.cc
@@ -65,13 +65,12 @@
                      ErrorPtr* error) {
   UwMacaroonCaveatType caveat_type{};
   if (!uw_macaroon_caveat_get_type_(&caveat, &caveat_type)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, kInvalidTokenError,
-                 "Unable to get type");
+    Error::AddTo(error, FROM_HERE, kInvalidTokenError, "Unable to get type");
     return false;
   }
 
   if (caveat_type != type) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, kInvalidTokenError,
+    Error::AddTo(error, FROM_HERE, kInvalidTokenError,
                  "Unexpected caveat type");
     return false;
   }
@@ -87,8 +86,7 @@
     return false;
 
   if (!uw_macaroon_caveat_get_value_uint_(&caveat, value)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, kInvalidTokenError,
-                 "Unable to read caveat");
+    Error::AddTo(error, FROM_HERE, kInvalidTokenError, "Unable to read caveat");
     return false;
   }
 
@@ -105,8 +103,7 @@
   const uint8_t* start{nullptr};
   size_t size{0};
   if (!uw_macaroon_caveat_get_value_str_(&caveat, &start, &size)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, kInvalidTokenError,
-                 "Unable to read caveat");
+    Error::AddTo(error, FROM_HERE, kInvalidTokenError, "Unable to read caveat");
     return false;
   }
 
@@ -147,8 +144,7 @@
   buffer->resize(kMaxMacaroonSize);
   if (!uw_macaroon_load_(token.data(), token.size(), buffer->data(),
                          buffer->size(), macaroon)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, kInvalidTokenError,
-                 "Invalid token format");
+    Error::AddTo(error, FROM_HERE, kInvalidTokenError, "Invalid token format");
     return false;
   }
   return true;
@@ -159,7 +155,7 @@
                     ErrorPtr* error) {
   CHECK_EQ(kSha256OutputSize, secret.size());
   if (!uw_macaroon_verify_(&macaroon, secret.data(), secret.size())) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, "invalid_signature",
+    Error::AddTo(error, FROM_HERE, "invalid_signature",
                  "Invalid token signature");
     return false;
   }
@@ -275,22 +271,22 @@
                   &user_id, error) ||
       !ReadCaveat(macaroon.caveats[2], kUwMacaroonCaveatTypeExpiration,
                   &expiration, error)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain,
-                 errors::kInvalidAuthorization, "Invalid token");
+    Error::AddTo(error, FROM_HERE, errors::kInvalidAuthorization,
+                 "Invalid token");
     return false;
   }
 
   AuthScope auth_scope{FromMacaroonScope(scope)};
   if (auth_scope == AuthScope::kNone) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain,
-                 errors::kInvalidAuthorization, "Invalid token data");
+    Error::AddTo(error, FROM_HERE, errors::kInvalidAuthorization,
+                 "Invalid token data");
     return false;
   }
 
   base::Time time{base::Time::FromTimeT(expiration)};
   if (time < clock_->Now()) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain,
-                 errors::kAuthorizationExpired, "Token is expired");
+    Error::AddTo(error, FROM_HERE, errors::kAuthorizationExpired,
+                 "Token is expired");
     return false;
   }
 
@@ -307,9 +303,9 @@
   if (config_) {
     auto current = config_->GetSettings().root_client_token_owner;
     if (!IsClaimAllowed(current, owner)) {
-      Error::AddToPrintf(
-          error, FROM_HERE, errors::kDomain, errors::kAlreadyClaimed,
-          "Device already claimed by '%s'", EnumToString(current).c_str());
+      Error::AddToPrintf(error, FROM_HERE, errors::kAlreadyClaimed,
+                         "Device already claimed by '%s'",
+                         EnumToString(current).c_str());
       return {};
     }
   };
@@ -333,8 +329,7 @@
                      return auth.first->IsValidAuthToken(token, nullptr);
                    });
   if (claim == pending_claims_.end()) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kNotFound,
-                 "Unknown claim");
+    Error::AddTo(error, FROM_HERE, errors::kNotFound, "Unknown claim");
     return false;
   }
 
@@ -363,8 +358,7 @@
   UwMacaroon macaroon{};
   if (!LoadMacaroon(token, &buffer, &macaroon, error) ||
       !VerifyMacaroon(auth_secret_, macaroon, error)) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidAuthCode,
-                 "Invalid token");
+    Error::AddTo(error, FROM_HERE, errors::kInvalidAuthCode, "Invalid token");
     return false;
   }
   return true;
diff --git a/src/privet/cloud_delegate.cc b/src/privet/cloud_delegate.cc
index 4bf47b3..0eb04e0 100644
--- a/src/privet/cloud_delegate.cc
+++ b/src/privet/cloud_delegate.cc
@@ -32,7 +32,7 @@
 
 CommandInstance* ReturnNotFound(const std::string& command_id,
                                 ErrorPtr* error) {
-  Error::AddToPrintf(error, FROM_HERE, errors::kDomain, errors::kNotFound,
+  Error::AddToPrintf(error, FROM_HERE, errors::kNotFound,
                      "Command not found, ID='%s'", command_id.c_str());
   return nullptr;
 }
@@ -171,9 +171,8 @@
     UserRole role;
     std::string str_scope = EnumToString(user_info.scope());
     if (!StringToEnum(str_scope, &role)) {
-      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                         errors::kInvalidParams, "Invalid role: '%s'",
-                         str_scope.c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                         "Invalid role: '%s'", str_scope.c_str());
       return callback.Run({}, std::move(error));
     }
 
@@ -251,9 +250,9 @@
       connection_state_ = ConnectionState{ConnectionState::kOnline};
     } else {
       ErrorPtr error;
-      Error::AddToPrintf(
-          &error, FROM_HERE, errors::kDomain, errors::kInvalidState,
-          "Unexpected registration status: %s", EnumToString(status).c_str());
+      Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidState,
+                         "Unexpected registration status: %s",
+                         EnumToString(status).c_str());
       connection_state_ = ConnectionState{std::move(error)};
     }
     NotifyOnDeviceInfoChanged();
@@ -268,7 +267,7 @@
     ErrorPtr error;
     CHECK_GE(registation_retry_count_, 0);
     if (registation_retry_count_-- == 0) {
-      Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+      Error::AddTo(&error, FROM_HERE, errors::kInvalidState,
                    "Failed to register device");
       setup_state_ = SetupState{std::move(error)};
       return;
@@ -321,7 +320,7 @@
       return true;
     }
 
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kAccessDenied,
+    Error::AddTo(error, FROM_HERE, errors::kAccessDenied,
                  "Need to be owner of the command.");
     return false;
   }
diff --git a/src/privet/constants.cc b/src/privet/constants.cc
index e1962bd..4278165 100644
--- a/src/privet/constants.cc
+++ b/src/privet/constants.cc
@@ -8,8 +8,6 @@
 namespace privet {
 namespace errors {
 
-const char kDomain[] = "privetd";
-
 const char kInvalidClientCommitment[] = "invalidClientCommitment";
 const char kInvalidFormat[] = "invalidFormat";
 const char kMissingAuthorization[] = "missingAuthorization";
diff --git a/src/privet/constants.h b/src/privet/constants.h
index 2b001aa..67f993d 100644
--- a/src/privet/constants.h
+++ b/src/privet/constants.h
@@ -10,8 +10,6 @@
 
 namespace errors {
 
-extern const char kDomain[];
-
 extern const char kInvalidClientCommitment[];
 extern const char kInvalidFormat[];
 extern const char kMissingAuthorization[];
diff --git a/src/privet/privet_handler.cc b/src/privet/privet_handler.cc
index db55861..e8b1c77 100644
--- a/src/privet/privet_handler.cc
+++ b/src/privet/privet_handler.cc
@@ -185,7 +185,7 @@
                  const PrivetHandler::RequestCallback& callback) {
   int code = http::kInternalServerError;
   for (const auto& it : kReasonToCode) {
-    if (error.HasError(errors::kDomain, it.reason)) {
+    if (error.HasError(it.reason)) {
       code = it.code;
       break;
     }
@@ -201,14 +201,12 @@
   if (!error)
     return callback.Run(http::kOk, output);
 
-  if (error->HasError("gcd", "unknown_command")) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kNotFound,
-                 "Unknown command ID");
+  if (error->HasError("unknown_command")) {
+    Error::AddTo(&error, FROM_HERE, errors::kNotFound, "Unknown command ID");
     return ReturnError(*error, callback);
   }
-  if (error->HasError("gcd", "access_denied")) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kAccessDenied,
-                 error->GetMessage());
+  if (error->HasError("access_denied")) {
+    Error::AddTo(&error, FROM_HERE, errors::kAccessDenied, error->GetMessage());
     return ReturnError(*error, callback);
   }
   return ReturnError(*error, callback);
@@ -471,26 +469,22 @@
                                   const RequestCallback& callback) {
   ErrorPtr error;
   if (!input) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidFormat,
-                 "Malformed JSON");
+    Error::AddTo(&error, FROM_HERE, errors::kInvalidFormat, "Malformed JSON");
     return ReturnError(*error, callback);
   }
   auto handler = handlers_.find(api);
   if (handler == handlers_.end()) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kNotFound,
-                 "Path not found");
+    Error::AddTo(&error, FROM_HERE, errors::kNotFound, "Path not found");
     return ReturnError(*error, callback);
   }
   if (auth_header.empty()) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                 errors::kMissingAuthorization,
+    Error::AddTo(&error, FROM_HERE, errors::kMissingAuthorization,
                  "Authorization header must not be empty");
     return ReturnError(*error, callback);
   }
   std::string token = GetAuthTokenFromAuthHeader(auth_header);
   if (token.empty()) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidAuthorization,
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidAuthorization,
                        "Invalid authorization header: %s", auth_header.c_str());
     return ReturnError(*error, callback);
   }
@@ -501,8 +495,7 @@
   }
 
   if (handler->second.scope > user_info.scope()) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidAuthorizationScope,
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidAuthorizationScope,
                        "Scope '%s' does not allow '%s'",
                        EnumToString(user_info.scope()).c_str(), api.c_str());
     return ReturnError(*error, callback);
@@ -590,9 +583,9 @@
   std::set<PairingType> modes = security_->GetPairingTypes();
   if (!StringToEnum(pairing_str, &pairing) ||
       modes.find(pairing) == modes.end()) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidParams, kInvalidParamValueFormat,
-                       kPairingKey, pairing_str.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                       kInvalidParamValueFormat, kPairingKey,
+                       pairing_str.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -600,9 +593,9 @@
   std::set<CryptoType> cryptos = security_->GetCryptoTypes();
   if (!StringToEnum(crypto_str, &crypto) ||
       cryptos.find(crypto) == cryptos.end()) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidParams, kInvalidParamValueFormat,
-                       kCryptoKey, crypto_str.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                       kInvalidParamValueFormat, kCryptoKey,
+                       crypto_str.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -663,9 +656,9 @@
   AuthType auth_type{};
   if (!input.GetString(kAuthModeKey, &auth_code_type) ||
       !StringToEnum(auth_code_type, &auth_type)) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidAuthMode, kInvalidParamValueFormat,
-                       kAuthModeKey, auth_code_type.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidAuthMode,
+                       kInvalidParamValueFormat, kAuthModeKey,
+                       auth_code_type.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -676,8 +669,7 @@
   input.GetString(kAuthRequestedScopeKey, &requested_scope);
   if (requested_scope != kAuthScopeAutoValue) {
     if (!StringToEnum(requested_scope, &desired_scope)) {
-      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                         errors::kInvalidRequestedScope,
+      Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidRequestedScope,
                          kInvalidParamValueFormat, kAuthRequestedScopeKey,
                          requested_scope.c_str());
       return ReturnError(*error, callback);
@@ -701,8 +693,8 @@
   }
 
   if (access_token_scope < acceptable_scope) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kAccessDenied, "Scope '%s' is not allowed",
+    Error::AddToPrintf(&error, FROM_HERE, errors::kAccessDenied,
+                       "Scope '%s' is not allowed",
                        EnumToString(access_token_scope).c_str());
     return ReturnError(*error, callback);
   }
@@ -737,9 +729,9 @@
 
   std::string token;
   if (!input.GetString(kAuthClientTokenKey, &token)) {
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidParams, kInvalidParamValueFormat,
-                       kAuthClientTokenKey, token.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                       kInvalidParamValueFormat, kAuthClientTokenKey,
+                       token.c_str());
     return ReturnError(*error, callback);
   }
 
@@ -771,16 +763,15 @@
   if (input.GetDictionary(kWifiKey, &wifi)) {
     if (!wifi_ || wifi_->GetTypes().empty()) {
       ErrorPtr error;
-      Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                   errors::kSetupUnavailable, "WiFi setup unavailable");
+      Error::AddTo(&error, FROM_HERE, errors::kSetupUnavailable,
+                   "WiFi setup unavailable");
       return ReturnError(*error, callback);
     }
     wifi->GetString(kSetupStartSsidKey, &ssid);
     if (ssid.empty()) {
       ErrorPtr error;
-      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                         errors::kInvalidParams, kInvalidParamValueFormat,
-                         kSetupStartSsidKey, "");
+      Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                         kInvalidParamValueFormat, kSetupStartSsidKey, "");
       return ReturnError(*error, callback);
     }
     wifi->GetString(kSetupStartPassKey, &passphrase);
@@ -790,17 +781,15 @@
   if (input.GetDictionary(kGcdKey, &registration)) {
     if (user_info.scope() < AuthScope::kOwner) {
       ErrorPtr error;
-      Error::AddTo(&error, FROM_HERE, errors::kDomain,
-                   errors::kInvalidAuthorizationScope,
+      Error::AddTo(&error, FROM_HERE, errors::kInvalidAuthorizationScope,
                    "Only owner can register device");
       return ReturnError(*error, callback);
     }
     registration->GetString(kSetupStartTicketIdKey, &ticket);
     if (ticket.empty()) {
       ErrorPtr error;
-      Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                         errors::kInvalidParams, kInvalidParamValueFormat,
-                         kSetupStartTicketIdKey, "");
+      Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                         kInvalidParamValueFormat, kSetupStartTicketIdKey, "");
       return ReturnError(*error, callback);
     }
     registration->GetString(kSetupStartUserKey, &user);
@@ -932,9 +921,8 @@
   std::string id;
   if (!input.GetString(kCommandsIdKey, &id)) {
     ErrorPtr error;
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidParams, kInvalidParamValueFormat,
-                       kCommandsIdKey, id.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                       kInvalidParamValueFormat, kCommandsIdKey, id.c_str());
     return ReturnError(*error, callback);
   }
   cloud_->GetCommand(id, user_info,
@@ -954,9 +942,8 @@
   std::string id;
   if (!input.GetString(kCommandsIdKey, &id)) {
     ErrorPtr error;
-    Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidParams, kInvalidParamValueFormat,
-                       kCommandsIdKey, id.c_str());
+    Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidParams,
+                       kInvalidParamValueFormat, kCommandsIdKey, id.c_str());
     return ReturnError(*error, callback);
   }
   cloud_->CancelCommand(id, user_info,
diff --git a/src/privet/privet_handler_unittest.cc b/src/privet/privet_handler_unittest.cc
index 6d6a289..a353a0f 100644
--- a/src/privet/privet_handler_unittest.cc
+++ b/src/privet/privet_handler_unittest.cc
@@ -136,7 +136,7 @@
         .WillRepeatedly(ReturnRef(gcd_disabled_state_));
     auto set_error = [](const std::string&, const std::string&,
                         ErrorPtr* error) {
-      Error::AddTo(error, FROM_HERE, errors::kDomain, "setupUnavailable", "");
+      Error::AddTo(error, FROM_HERE, "setupUnavailable", "");
     };
     EXPECT_CALL(cloud_, Setup(_, _, _))
         .WillRepeatedly(DoAll(Invoke(set_error), Return(false)));
@@ -198,7 +198,7 @@
   auth_header_ = "Privet 123";
   EXPECT_CALL(security_, ParseAccessToken(_, _, _))
       .WillRepeatedly(DoAll(WithArgs<2>(Invoke([](ErrorPtr* error) {
-                              Error::AddTo(error, FROM_HERE, errors::kDomain,
+                              Error::AddTo(error, FROM_HERE,
                                            "authorizationExpired", "");
                             })),
                             Return(false)));
@@ -379,7 +379,7 @@
 
 TEST_F(PrivetHandlerTest, AuthErrorInvalidAuthCode) {
   auto set_error = [](ErrorPtr* error) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, "invalidAuthCode", "");
+    Error::AddTo(error, FROM_HERE, "invalidAuthCode", "");
   };
   EXPECT_CALL(security_, CreateAccessToken(_, "testToken", _, _, _, _, _))
       .WillRepeatedly(DoAll(WithArgs<6>(Invoke(set_error)), Return(false)));
@@ -511,7 +511,7 @@
 
 TEST_F(PrivetHandlerSetupTest, StatusWifiError) {
   ErrorPtr error;
-  Error::AddTo(&error, FROM_HERE, "test", "invalidPassphrase", "");
+  Error::AddTo(&error, FROM_HERE, "invalidPassphrase", "");
   wifi_.setup_state_ = SetupState{std::move(error)};
 
   const char kExpected[] = R"({
@@ -541,7 +541,7 @@
 
 TEST_F(PrivetHandlerSetupTest, StatusGcdError) {
   ErrorPtr error;
-  Error::AddTo(&error, FROM_HERE, "test", "invalidTicket", "");
+  Error::AddTo(&error, FROM_HERE, "invalidTicket", "");
   cloud_.setup_state_ = SetupState{std::move(error)};
 
   const char kExpected[] = R"({
@@ -601,7 +601,7 @@
     }
   })";
   auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
+    Error::AddTo(error, FROM_HERE, "deviceBusy", "");
   };
   EXPECT_CALL(wifi_, ConfigureCredentials(_, _, _))
       .WillOnce(DoAll(Invoke(set_error), Return(false)));
@@ -641,7 +641,7 @@
   })";
 
   auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
+    Error::AddTo(error, FROM_HERE, "deviceBusy", "");
   };
   EXPECT_CALL(cloud_, Setup(_, _, _))
       .WillOnce(DoAll(Invoke(set_error), Return(false)));
@@ -857,7 +857,7 @@
           "{'path':'comp1.comp2', 'filter':['traits', 'components']}"));
 
   auto error_handler = [](ErrorPtr* error) -> const base::DictionaryValue* {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, "componentNotFound", "");
+    Error::AddTo(error, FROM_HERE, "componentNotFound", "");
     return nullptr;
   };
   EXPECT_CALL(cloud_, FindComponent("comp7", _))
@@ -899,7 +899,7 @@
                  HandleRequest("/privet/v3/commands/status", kInput));
 
   ErrorPtr error;
-  Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
+  Error::AddTo(&error, FROM_HERE, "notFound", "");
   EXPECT_CALL(cloud_, GetCommand(_, _, _))
       .WillOnce(WithArgs<2>(
           Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
@@ -924,7 +924,7 @@
                  HandleRequest("/privet/v3/commands/cancel", "{'id': '8'}"));
 
   ErrorPtr error;
-  Error::AddTo(&error, FROM_HERE, errors::kDomain, "notFound", "");
+  Error::AddTo(&error, FROM_HERE, "notFound", "");
   EXPECT_CALL(cloud_, CancelCommand(_, _, _))
       .WillOnce(WithArgs<2>(
           Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
diff --git a/src/privet/security_manager.cc b/src/privet/security_manager.cc
index 2a3dc08..7a3533a 100644
--- a/src/privet/security_manager.cc
+++ b/src/privet/security_manager.cc
@@ -51,8 +51,8 @@
       case crypto::P224EncryptedKeyExchange::kResultPending:
         return true;
       case crypto::P224EncryptedKeyExchange::kResultFailed:
-        Error::AddTo(error, FROM_HERE, errors::kDomain,
-                     errors::kInvalidClientCommitment, spake_.error());
+        Error::AddTo(error, FROM_HERE, errors::kInvalidClientCommitment,
+                     spake_.error());
         return false;
       default:
         LOG(FATAL) << "SecurityManager uses only one round trip";
@@ -139,7 +139,7 @@
     base::TimeDelta* access_token_ttl,
     ErrorPtr* error) {
   auto disabled_mode = [](ErrorPtr* error) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidAuthMode,
+    Error::AddTo(error, FROM_HERE, errors::kInvalidAuthMode,
                  "Mode is not available");
     return false;
   };
@@ -154,8 +154,8 @@
       if (!IsPairingAuthSupported())
         return disabled_mode(error);
       if (!IsValidPairingCode(auth_code)) {
-        Error::AddTo(error, FROM_HERE, errors::kDomain,
-                     errors::kInvalidAuthCode, "Invalid authCode");
+        Error::AddTo(error, FROM_HERE, errors::kInvalidAuthCode,
+                     "Invalid authCode");
         return false;
       }
       return CreateAccessTokenImpl(auth_type, desired_scope, access_token,
@@ -170,7 +170,7 @@
           error);
   }
 
-  Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidAuthMode,
+  Error::AddTo(error, FROM_HERE, errors::kInvalidAuthMode,
                "Unsupported auth mode");
   return false;
 }
@@ -185,8 +185,7 @@
   std::vector<uint8_t> auth_decoded;
   if (auth_type != AuthType::kAnonymous &&
       !Base64Decode(auth_code, &auth_decoded)) {
-    Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidAuthorization,
+    Error::AddToPrintf(error, FROM_HERE, errors::kInvalidAuthorization,
                        "Invalid auth_code encoding: %s", auth_code.c_str());
     return false;
   }
@@ -209,8 +208,7 @@
                                        ErrorPtr* error) const {
   std::vector<uint8_t> decoded;
   if (!Base64Decode(token, &decoded)) {
-    Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidAuthorization,
+    Error::AddToPrintf(error, FROM_HERE, errors::kInvalidAuthorization,
                        "Invalid token encoding: %s", token.c_str());
     return false;
   }
@@ -252,8 +250,7 @@
                                              ErrorPtr* error) {
   std::vector<uint8_t> token_decoded;
   if (!Base64Decode(token, &token_decoded)) {
-    Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                       errors::kInvalidFormat,
+    Error::AddToPrintf(error, FROM_HERE, errors::kInvalidFormat,
                        "Invalid auth token string: '%s'", token.c_str());
     return false;
   }
@@ -293,7 +290,7 @@
   const auto& pairing_modes = GetSettings().pairing_modes;
   if (std::find(pairing_modes.begin(), pairing_modes.end(), mode) ==
       pairing_modes.end()) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+    Error::AddTo(error, FROM_HERE, errors::kInvalidParams,
                  "Pairing mode is not enabled");
     return false;
   }
@@ -308,7 +305,7 @@
       code = base::StringPrintf("%04i", base::RandInt(0, 9999));
       break;
     default:
-      Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+      Error::AddTo(error, FROM_HERE, errors::kInvalidParams,
                    "Unsupported pairing mode");
       return false;
   }
@@ -325,7 +322,7 @@
       }
     // Fall through...
     default:
-      Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kInvalidParams,
+      Error::AddTo(error, FROM_HERE, errors::kInvalidParams,
                    "Unsupported crypto");
       return false;
   }
@@ -368,25 +365,24 @@
                                      ErrorPtr* error) {
   auto session = pending_sessions_.find(session_id);
   if (session == pending_sessions_.end()) {
-    Error::AddToPrintf(error, FROM_HERE, errors::kDomain,
-                       errors::kUnknownSession, "Unknown session id: '%s'",
-                       session_id.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::kUnknownSession,
+                       "Unknown session id: '%s'", session_id.c_str());
     return false;
   }
 
   std::vector<uint8_t> commitment;
   if (!Base64Decode(client_commitment, &commitment)) {
     ClosePendingSession(session_id);
-    Error::AddToPrintf(
-        error, FROM_HERE, errors::kDomain, errors::kInvalidFormat,
-        "Invalid commitment string: '%s'", client_commitment.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::kInvalidFormat,
+                       "Invalid commitment string: '%s'",
+                       client_commitment.c_str());
     return false;
   }
 
   if (!session->second->ProcessMessage(
           std::string(commitment.begin(), commitment.end()), error)) {
     ClosePendingSession(session_id);
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kCommitmentMismatch,
+    Error::AddTo(error, FROM_HERE, errors::kCommitmentMismatch,
                  "Pairing code or crypto implementation mismatch");
     return false;
   }
@@ -422,7 +418,7 @@
   CHECK(!confirmed || !pending);
   if (confirmed || pending)
     return true;
-  Error::AddToPrintf(error, FROM_HERE, errors::kDomain, errors::kUnknownSession,
+  Error::AddToPrintf(error, FROM_HERE, errors::kUnknownSession,
                      "Unknown session id: '%s'", session_id.c_str());
   return false;
 }
@@ -444,7 +440,7 @@
     return true;
 
   if (block_pairing_until_ > auth_manager_->Now()) {
-    Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kDeviceBusy,
+    Error::AddTo(error, FROM_HERE, errors::kDeviceBusy,
                  "Too many pairing attempts");
     return false;
   }
diff --git a/src/privet/wifi_bootstrap_manager.cc b/src/privet/wifi_bootstrap_manager.cc
index 086e21c..566da80 100644
--- a/src/privet/wifi_bootstrap_manager.cc
+++ b/src/privet/wifi_bootstrap_manager.cc
@@ -211,7 +211,7 @@
 void WifiBootstrapManager::OnConnectDone(const std::string& ssid,
                                          ErrorPtr error) {
   if (error) {
-    Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+    Error::AddTo(&error, FROM_HERE, errors::kInvalidState,
                  "Failed to connect to provided network");
     setup_state_ = SetupState{std::move(error)};
     return StartBootstrapping();
@@ -226,7 +226,7 @@
 
 void WifiBootstrapManager::OnConnectTimeout() {
   ErrorPtr error;
-  Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+  Error::AddTo(&error, FROM_HERE, errors::kInvalidState,
                "Timeout connecting to provided network");
   setup_state_ = SetupState{std::move(error)};
   return StartBootstrapping();
@@ -265,7 +265,7 @@
     case Network::State::kError: {
       // TODO(wiley) Pull error information from somewhere.
       ErrorPtr error;
-      Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+      Error::AddTo(&error, FROM_HERE, errors::kInvalidState,
                    "Unknown WiFi error");
       connection_state_ = ConnectionState{std::move(error)};
       return;
@@ -278,7 +278,7 @@
       return;
   }
   ErrorPtr error;
-  Error::AddToPrintf(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
+  Error::AddToPrintf(&error, FROM_HERE, errors::kInvalidState,
                      "Unknown network state: %s",
                      EnumToString(service_state).c_str());
   connection_state_ = ConnectionState{std::move(error)};