[Sync] Move //components/sync_driver to //components/sync/driver.

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 "components/sync/driver/about_sync_util.h"
 
 #include <string>
 #include <utility>
 
 #include "base/location.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/base/sync_string_conversions.h"
+#include "components/sync/driver/sync_service.h"
 #include "components/sync/engine/sync_status.h"
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/sync/sessions/sync_session_snapshot.h"
-#include "components/sync_driver/sync_service.h"
 #include "components/version_info/version_info.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 
 namespace sync_driver {
 
 namespace sync_ui_util {
 
 const char kIdentityTitle[] = "Identity";
@@ skipping 236 matching lines @@
       AddSensitiveSection(stats_list, kIdentityTitle);
   StringSyncStat sync_id(section_identity, "Sync Client ID");
   StringSyncStat invalidator_id(section_identity, "Invalidator Client ID");
   StringSyncStat username(section_identity, "Username");
 
   base::ListValue* section_credentials = AddSection(stats_list, "Credentials");
   StringSyncStat request_token_time(section_credentials, "Requested Token");
   StringSyncStat receive_token_time(section_credentials, "Received Token");
   StringSyncStat token_request_status(section_credentials,
                                       "Token Request Status");
-  StringSyncStat next_token_request(section_credentials,
-                                    "Next Token Request");
+  StringSyncStat next_token_request(section_credentials, "Next Token Request");
 
   base::ListValue* section_local = AddSection(stats_list, "Local State");
-  StringSyncStat server_connection(section_local,
-                                   "Server Connection");
+  StringSyncStat server_connection(section_local, "Server Connection");
   StringSyncStat last_synced(section_local, "Last Synced");
   BoolSyncStat is_setup_complete(section_local,
                                  "Sync First-Time Setup Complete");
   StringSyncStat backend_initialization(section_local,
                                         "Sync Backend Initialization");
   BoolSyncStat is_syncing(section_local, "Syncing");
 
   base::ListValue* section_network = AddSection(stats_list, "Network");
   BoolSyncStat is_throttled(section_network, "Throttled");
   StringSyncStat retry_time(section_network, "Retry time (maybe stale)");
   BoolSyncStat are_notifications_enabled(section_network,
                                          "Notifications Enabled");
 
   base::ListValue* section_encryption = AddSection(stats_list, "Encryption");
   BoolSyncStat is_using_explicit_passphrase(section_encryption,
                                             "Explicit Passphrase");
   BoolSyncStat is_passphrase_required(section_encryption,
                                       "Passphrase Required");
   BoolSyncStat is_cryptographer_ready(section_encryption,
                                       "Cryptographer Ready");
   BoolSyncStat has_pending_keys(section_encryption,
                                 "Cryptographer Has Pending Keys");
   StringSyncStat encrypted_types(section_encryption, "Encrypted Types");
   BoolSyncStat has_keystore_key(section_encryption, "Has Keystore Key");
   StringSyncStat keystore_migration_time(section_encryption,
                                          "Keystore Migration Time");
-  StringSyncStat passphrase_type(section_encryption,
-                                 "Passphrase Type");
-  StringSyncStat passphrase_time(section_encryption,
-                                 "Passphrase Time");
+  StringSyncStat passphrase_type(section_encryption, "Passphrase Type");
+  StringSyncStat passphrase_time(section_encryption, "Passphrase Time");
 
-  base::ListValue* section_last_session = AddSection(
-      stats_list, "Status from Last Completed Session");
+  base::ListValue* section_last_session =
+      AddSection(stats_list, "Status from Last Completed Session");
   StringSyncStat session_source(section_last_session, "Sync Source");
   StringSyncStat get_key_result(section_last_session, "GetKey Step Result");
   StringSyncStat download_result(section_last_session, "Download Step Result");
   StringSyncStat commit_result(section_last_session, "Commit Step Result");
 
   base::ListValue* section_counters = AddSection(stats_list, "Running Totals");
   IntSyncStat notifications_received(section_counters,
                                      "Notifications Received");
   IntSyncStat updates_received(section_counters, "Updates Downloaded");
   IntSyncStat tombstone_updates(section_counters, "Tombstone Updates");
   IntSyncStat reflected_updates(section_counters, "Reflected Updates");
   IntSyncStat successful_commits(section_counters, "Successful Commits");
   IntSyncStat conflicts_resolved_local_wins(section_counters,
-                                     "Conflicts Resolved: Client Wins");
+                                            "Conflicts Resolved: Client Wins");
   IntSyncStat conflicts_resolved_server_wins(section_counters,
-                                      "Conflicts Resolved: Server Wins");
+                                             "Conflicts Resolved: Server Wins");
 
-  base::ListValue *section_this_cycle = AddSection(stats_list,
-                                             "Transient Counters (this cycle)");
+  base::ListValue* section_this_cycle =
+      AddSection(stats_list, "Transient Counters (this cycle)");
   IntSyncStat encryption_conflicts(section_this_cycle, "Encryption Conflicts");
   IntSyncStat hierarchy_conflicts(section_this_cycle, "Hierarchy Conflicts");
   IntSyncStat server_conflicts(section_this_cycle, "Server Conflicts");
   IntSyncStat committed_items(section_this_cycle, "Committed Items");
 
   base::ListValue* section_that_cycle = AddSection(
       stats_list, "Transient Counters (last cycle of last completed session)");
   IntSyncStat updates_downloaded(section_that_cycle, "Updates Downloaded");
   IntSyncStat committed_count(section_that_cycle, "Committed Count");
   IntSyncStat entries(section_that_cycle, "Entries");
 
-  base::ListValue* section_nudge_info = AddSection(
-      stats_list, "Nudge Source Counters");
-  IntSyncStat nudge_source_notification(
-      section_nudge_info, "Server Invalidations");
+  base::ListValue* section_nudge_info =
+      AddSection(stats_list, "Nudge Source Counters");
+  IntSyncStat nudge_source_notification(section_nudge_info,
+                                        "Server Invalidations");
   IntSyncStat nudge_source_local(section_nudge_info, "Local Changes");
   IntSyncStat nudge_source_local_refresh(section_nudge_info, "Local Refreshes");
 
   // This list of sections belongs in the 'details' field of the returned
   // message.
   about_info->Set(kDetailsKey, stats_list);
 
   // Populate all the fields we declared above.
   client_version.SetValue(GetVersionString(channel));
 
@@ skipping 16 matching lines @@
   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 =
       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"));
+  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"));
 
   last_synced.SetValue(service->GetLastSyncedTimeString());
   is_setup_complete.SetValue(service->IsFirstSetupComplete());
   backend_initialization.SetValue(
       service->GetBackendInitializationStateString());
   if (is_status_valid) {
     is_syncing.SetValue(full_status.syncing);
     retry_time.SetValue(GetTimeStr(full_status.retry_time,
-        "Scheduler is not in backoff or throttled"));
+                                   "Scheduler is not in backoff or throttled"));
   }
 
   if (snapshot.is_initialized())
     is_throttled.SetValue(snapshot.is_silenced());
   if (is_status_valid) {
-    are_notifications_enabled.SetValue(
-        full_status.notifications_enabled);
+    are_notifications_enabled.SetValue(full_status.notifications_enabled);
   }
 
   if (sync_active) {
     is_using_explicit_passphrase.SetValue(
         service->IsUsingSecondaryPassphrase());
     is_passphrase_required.SetValue(service->IsPassphraseRequired());
     passphrase_time.SetValue(
         GetTimeStr(service->GetExplicitPassphraseTime(), "No Passphrase Time"));
   }
   if (is_status_valid) {
     is_cryptographer_ready.SetValue(full_status.cryptographer_ready);
     has_pending_keys.SetValue(full_status.crypto_has_pending_keys);
-    encrypted_types.SetValue(
-        ModelTypeSetToString(full_status.encrypted_types));
+    encrypted_types.SetValue(ModelTypeSetToString(full_status.encrypted_types));
     has_keystore_key.SetValue(full_status.has_keystore_key);
     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()));
     }
-    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));
+    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));
+        GetSyncerErrorString(snapshot.model_neutral_state().commit_result));
   }
 
   if (is_status_valid) {
     notifications_received.SetValue(full_status.notifications_received);
     updates_received.SetValue(full_status.updates_received);
     tombstone_updates.SetValue(full_status.tombstone_updates_received);
     reflected_updates.SetValue(full_status.reflected_updates_received);
     successful_commits.SetValue(full_status.num_commits_total);
     conflicts_resolved_local_wins.SetValue(
         full_status.num_local_overwrites_total);
@@ skipping 41 matching lines @@
   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));
-    action.SetValue(syncer::GetClientActionString(
-            full_status.sync_protocol_error.action));
+        full_status.sync_protocol_error.error_type));
+    action.SetValue(
+        syncer::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();
+        "Unrecoverable error detected at " + location_str + ": " +
+        service->unrecoverable_error_message();
     about_info->SetString("unrecoverable_error_message",
-                       unrecoverable_error_message);
+                          unrecoverable_error_message);
   }
 
   about_info->Set("type_status", service->GetTypeStatusMap());
 
   return about_info;
 }
 
 }  // namespace sync_ui_util
 
 }  // namespace sync_driver