[Sync] Move //components/sync to the syncer namespace.

components/sync/driver/about_sync_util.cc

 // Copyright (c) 2012 The Chromium 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 "components/sync/driver/about_sync_util.h"
 
 #include <string>
 #include <utility>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync/api/time.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "components/sync/engine/sync_status.h"
 #include "components/sync/engine/sync_string_conversions.h"
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/version_info/version_info.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 
-namespace sync_driver {
+namespace syncer {
 
 namespace sync_ui_util {
 
 const char kIdentityTitle[] = "Identity";
 const char kDetailsKey[] = "details";
 
 // Resource paths.
 const char kAboutJS[] = "about.js";
 const char kChromeSyncJS[] = "chrome_sync.js";
 const char kDataJS[] = "data.js";
@@ skipping 161 matching lines @@
   return version_info::GetProductName() + " " + version_info::GetOSType() +
          " " + version_info::GetVersionNumber() + " (" +
          version_info::GetLastChange() + ")" + version_modifier;
 }
 
 std::string GetTimeStr(base::Time time, const std::string& default_msg) {
   std::string time_str;
   if (time.is_null())
     time_str = default_msg;
   else
-    time_str = syncer::GetTimeDebugString(time);
+    time_str = GetTimeDebugString(time);
   return time_str;
 }
 
-std::string GetConnectionStatus(
-    const sync_driver::SyncService::SyncTokenStatus& status) {
+std::string GetConnectionStatus(const SyncService::SyncTokenStatus& status) {
   std::string message;
   switch (status.connection_status) {
-    case syncer::CONNECTION_NOT_ATTEMPTED:
+    case CONNECTION_NOT_ATTEMPTED:
       base::StringAppendF(&message, "not attempted");
       break;
-    case syncer::CONNECTION_OK:
+    case CONNECTION_OK:
       base::StringAppendF(
           &message, "OK since %s",
           GetTimeStr(status.connection_status_update_time, "n/a").c_str());
       break;
-    case syncer::CONNECTION_AUTH_ERROR:
+    case CONNECTION_AUTH_ERROR:
       base::StringAppendF(
           &message, "auth error since %s",
           GetTimeStr(status.connection_status_update_time, "n/a").c_str());
       break;
-    case syncer::CONNECTION_SERVER_ERROR:
+    case CONNECTION_SERVER_ERROR:
       base::StringAppendF(
           &message, "server error since %s",
           GetTimeStr(status.connection_status_update_time, "n/a").c_str());
       break;
     default:
       NOTREACHED();
   }
   return message;
 }
 
 }  // namespace
 
 // This function both defines the structure of the message to be returned and
 // its contents.  Most of the message consists of simple fields in about:sync
 // which are grouped into sections and populated with the help of the SyncStat
 // classes defined above.
 std::unique_ptr<base::DictionaryValue> ConstructAboutInformation(
-    sync_driver::SyncService* service,
+    SyncService* service,
     SigninManagerBase* signin,
     version_info::Channel channel) {
   std::unique_ptr<base::DictionaryValue> about_info(
       new base::DictionaryValue());
 
   // 'details': A list of sections.
   base::ListValue* stats_list = new base::ListValue();
 
   // The following lines define the sections and their fields.  For each field,
   // a class is instantiated, which allows us to reference the fields in
@@ skipping 93 matching lines @@
   about_info->Set(kDetailsKey, stats_list);
 
   // Populate all the fields we declared above.
   client_version.SetValue(GetVersionString(channel));
 
   if (!service) {
     summary_string.SetValue("Sync service does not exist");
     return about_info;
   }
 
-  syncer::SyncStatus full_status;
+  SyncStatus full_status;
   bool is_status_valid = service->QueryDetailedSyncStatus(&full_status);
   bool sync_active = service->IsSyncActive();
-  const syncer::SyncCycleSnapshot& snapshot = service->GetLastCycleSnapshot();
+  const SyncCycleSnapshot& snapshot = service->GetLastCycleSnapshot();
 
   if (is_status_valid)
     summary_string.SetValue(service->QuerySyncStatusSummaryString());
 
   server_url.SetValue(service->sync_service_url().spec());
 
   if (is_status_valid && !full_status.sync_id.empty())
     sync_id.SetValue(full_status.sync_id);
   if (is_status_valid && !full_status.invalidator_client_id.empty())
     invalidator_id.SetValue(full_status.invalidator_client_id);
   if (signin)
     username.SetValue(signin->GetAuthenticatedAccountInfo().email);
 
-  const sync_driver::SyncService::SyncTokenStatus& token_status =
+  const SyncService::SyncTokenStatus& token_status =
       service->GetSyncTokenStatus();
   server_connection.SetValue(GetConnectionStatus(token_status));
   request_token_time.SetValue(
       GetTimeStr(token_status.token_request_time, "n/a"));
   receive_token_time.SetValue(
       GetTimeStr(token_status.token_receive_time, "n/a"));
   std::string err = token_status.last_get_token_error.error_message();
   token_request_status.SetValue(err.empty() ? "OK" : err);
   next_token_request.SetValue(
       GetTimeStr(token_status.next_token_request_time, "not scheduled"));
@@ skipping 29 matching lines @@
     keystore_migration_time.SetValue(
         GetTimeStr(full_status.keystore_migration_time, "Not Migrated"));
     passphrase_type.SetValue(
         PassphraseTypeToString(full_status.passphrase_type));
   }
 
   if (snapshot.is_initialized()) {
     if (snapshot.legacy_updates_source() !=
         sync_pb::GetUpdatesCallerInfo::UNKNOWN) {
       session_source.SetValue(
-          syncer::GetUpdatesSourceString(snapshot.legacy_updates_source()));
+          GetUpdatesSourceString(snapshot.legacy_updates_source()));
     }
     get_key_result.SetValue(GetSyncerErrorString(
         snapshot.model_neutral_state().last_get_key_result));
     download_result.SetValue(GetSyncerErrorString(
         snapshot.model_neutral_state().last_download_updates_result));
     commit_result.SetValue(
         GetSyncerErrorString(snapshot.model_neutral_state().commit_result));
   }
 
   if (is_status_valid) {
@@ skipping 29 matching lines @@
     entries.SetValue(snapshot.num_entries());
   }
 
   // The values set from this point onwards do not belong in the
   // details list.
 
   // We don't need to check is_status_valid here.
   // full_status.sync_protocol_error is exported directly from the
   // ProfileSyncService, even if the backend doesn't exist.
   const bool actionable_error_detected =
-      full_status.sync_protocol_error.error_type != syncer::UNKNOWN_ERROR &&
-      full_status.sync_protocol_error.error_type != syncer::SYNC_SUCCESS;
+      full_status.sync_protocol_error.error_type != UNKNOWN_ERROR &&
+      full_status.sync_protocol_error.error_type != SYNC_SUCCESS;
 
   about_info->SetBoolean("actionable_error_detected",
                          actionable_error_detected);
 
   // NOTE: We won't bother showing any of the following values unless
   // actionable_error_detected is set.
 
   base::ListValue* actionable_error = new base::ListValue();
   about_info->Set("actionable_error", actionable_error);
 
   StringSyncStat error_type(actionable_error, "Error Type");
   StringSyncStat action(actionable_error, "Action");
   StringSyncStat url(actionable_error, "URL");
   StringSyncStat description(actionable_error, "Error Description");
 
   if (actionable_error_detected) {
-    error_type.SetValue(syncer::GetSyncErrorTypeString(
-        full_status.sync_protocol_error.error_type));
+    error_type.SetValue(
+        GetSyncErrorTypeString(full_status.sync_protocol_error.error_type));
     action.SetValue(
-        syncer::GetClientActionString(full_status.sync_protocol_error.action));
+        GetClientActionString(full_status.sync_protocol_error.action));
     url.SetValue(full_status.sync_protocol_error.url);
     description.SetValue(full_status.sync_protocol_error.error_description);
   }
 
   about_info->SetBoolean("unrecoverable_error_detected",
                          service->HasUnrecoverableError());
 
   if (service->HasUnrecoverableError()) {
     tracked_objects::Location loc(service->unrecoverable_error_location());
     std::string location_str;
     loc.Write(true, true, &location_str);
     std::string unrecoverable_error_message =
         "Unrecoverable error detected at " + location_str + ": " +
         service->unrecoverable_error_message();
     about_info->SetString("unrecoverable_error_message",
                           unrecoverable_error_message);
   }
 
   about_info->Set("type_status", service->GetTypeStatusMap());
 
   return about_info;
 }
 
 }  // namespace sync_ui_util
 
-}  // namespace sync_driver
+}  // namespace syncer