[Sync] Merge //components/browser_sync into one directory.

components/browser_sync/profile_sync_service.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/browser_sync/browser/profile_sync_service.h"
+#include "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
-#include "components/browser_sync/common/browser_sync_switches.h"
+#include "components/browser_sync/browser_sync_switches.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/invalidation/impl/invalidation_prefs.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/signin/core/browser/about_signin_internals.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/strings/grit/components_strings.h"
@@ skipping 70 matching lines @@
 using syncer::JsEventHandler;
 using syncer::ModelSafeRoutingInfo;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
 using syncer::WeakHandle;
 using syncer_v2::ModelTypeStore;
 using syncer_v2::SharedModelTypeProcessor;
 
 typedef GoogleServiceAuthError AuthError;
 
-const char kSyncUnrecoverableErrorHistogram[] =
-    "Sync.UnrecoverableErrors";
+const char kSyncUnrecoverableErrorHistogram[] = "Sync.UnrecoverableErrors";
 
 const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     0,
 
     // Initial delay for exponential back-off in ms.
     2000,
 
     // Factor by which the waiting time will be multiplied.
@@ skipping 27 matching lines @@
 // This should only be called on the sync thread.
 void DeleteSyncDataFolder(const base::FilePath& directory_path) {
   if (base::DirectoryExists(directory_path)) {
     if (!base::DeleteFile(directory_path, true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace
 
-bool ShouldShowActionOnUI(
-    const syncer::SyncProtocolError& error) {
+bool ShouldShowActionOnUI(const syncer::SyncProtocolError& error) {
   return (error.action != syncer::UNKNOWN_ACTION &&
           error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT &&
           error.action != syncer::RESET_LOCAL_SYNC_DATA);
 }
 
 ProfileSyncService::InitParams::InitParams() = default;
 ProfileSyncService::InitParams::~InitParams() = default;
 ProfileSyncService::InitParams::InitParams(InitParams&& other)  // NOLINT
     : sync_client(std::move(other.sync_client)),
@@ skipping 270 matching lines @@
     return device_info_sync_service_.get();
   }
 }
 
 sync_driver::LocalDeviceInfoProvider*
 ProfileSyncService::GetLocalDeviceInfoProvider() const {
   return local_device_.get();
 }
 
 void ProfileSyncService::GetDataTypeControllerStates(
-  DataTypeController::StateMap* state_map) const {
+    DataTypeController::StateMap* state_map) const {
   for (DataTypeController::TypeMap::const_iterator iter =
            data_type_controllers_.begin();
        iter != data_type_controllers_.end(); ++iter)
-      (*state_map)[iter->first] = iter->second.get()->state();
+    (*state_map)[iter->first] = iter->second.get()->state();
 }
 
 void ProfileSyncService::OnSessionRestoreComplete() {
   DataTypeController::TypeMap::const_iterator iter =
       data_type_controllers_.find(syncer::SESSIONS);
   if (iter == data_type_controllers_.end()) {
     return;
   }
   DCHECK(iter->second);
 
@@ skipping 28 matching lines @@
 
   SyncCredentials credentials = GetCredentials();
 
   if (delete_stale_data)
     ClearStaleErrors();
 
   SyncBackendHost::HttpPostProviderFactoryGetter
       http_post_provider_factory_getter =
           base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                      base::Unretained(network_resources_.get()),
-                     url_request_context_,
-                     network_time_update_callback_);
+                     url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, std::move(sync_thread_), db_thread_, file_thread_,
       GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
       credentials, delete_stale_data,
       std::unique_ptr<syncer::SyncManagerFactory>(
           new syncer::SyncManagerFactory()),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(browser_sync::ChromeReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
 }
 
-void ProfileSyncService::OnProtocolEvent(
-    const syncer::ProtocolEvent& event) {
+void ProfileSyncService::OnProtocolEvent(const syncer::ProtocolEvent& event) {
   FOR_EACH_OBSERVER(browser_sync::ProtocolEventObserver,
-                    protocol_event_observers_,
-                    OnProtocolEvent(event));
+                    protocol_event_observers_, OnProtocolEvent(event));
 }
 
 void ProfileSyncService::OnDirectoryTypeCommitCounterUpdated(
     syncer::ModelType type,
     const syncer::CommitCounters& counters) {
-  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver,
-                    type_debug_info_observers_,
+  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, type_debug_info_observers_,
                     OnCommitCountersUpdated(type, counters));
 }
 
 void ProfileSyncService::OnDirectoryTypeUpdateCounterUpdated(
     syncer::ModelType type,
     const syncer::UpdateCounters& counters) {
-  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver,
-                    type_debug_info_observers_,
+  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, type_debug_info_observers_,
                     OnUpdateCountersUpdated(type, counters));
 }
 
 void ProfileSyncService::OnDirectoryTypeStatusCounterUpdated(
     syncer::ModelType type,
     const syncer::StatusCounters& counters) {
-  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver,
-                    type_debug_info_observers_,
+  FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, type_debug_info_observers_,
                     OnStatusCountersUpdated(type, counters));
 }
 
-void ProfileSyncService::OnDataTypeRequestsSyncStartup(
-    syncer::ModelType type) {
+void ProfileSyncService::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {
   DCHECK(syncer::UserTypes().Has(type));
 
   if (!GetPreferredDataTypes().Has(type)) {
     // We can get here as datatype SyncableServices are typically wired up
     // to the native datatype even if sync isn't enabled.
     DVLOG(1) << "Dropping sync startup request because type "
              << syncer::ModelTypeToString(type) << "not enabled.";
     return;
   }
 
@@ skipping 62 matching lines @@
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   last_get_token_error_ = error;
   switch (error.state()) {
     case GoogleServiceAuthError::CONNECTION_FAILED:
     case GoogleServiceAuthError::REQUEST_CANCELED:
     case GoogleServiceAuthError::SERVICE_ERROR:
     case GoogleServiceAuthError::SERVICE_UNAVAILABLE: {
       // Transient error. Retry after some time.
       request_access_token_backoff_.InformOfRequest(false);
-      next_token_request_time_ = base::Time::Now() +
+      next_token_request_time_ =
+          base::Time::Now() +
           request_access_token_backoff_.GetTimeUntilRelease();
       request_access_token_retry_timer_.Start(
           FROM_HERE, request_access_token_backoff_.GetTimeUntilRelease(),
           base::Bind(&ProfileSyncService::RequestAccessToken,
                      sync_enabled_weak_factory_.GetWeakPtr()));
       NotifyObservers();
       break;
     }
     case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS: {
       if (!sync_prefs_.SyncHasAuthError()) {
         sync_prefs_.SetSyncAuthError(true);
-        UMA_HISTOGRAM_ENUMERATION("Sync.SyncAuthError",
-                                  AUTH_ERROR_ENCOUNTERED,
+        UMA_HISTOGRAM_ENUMERATION("Sync.SyncAuthError", AUTH_ERROR_ENCOUNTERED,
                                   AUTH_ERROR_LIMIT);
       }
       // Fallthrough.
     }
     default: {
       if (error.state() != GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS) {
         LOG(ERROR) << "Unexpected persistent error: " << error.ToString();
       }
       // Show error to user.
       UpdateAuthErrorState(error);
     }
   }
 }
 
 void ProfileSyncService::OnRefreshTokenAvailable(
     const std::string& account_id) {
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 ProfileSyncService::OnRefreshTokenAvailable"));
 
   if (account_id == signin_->GetAccountIdToUse())
     OnRefreshTokensLoaded();
 }
 
-void ProfileSyncService::OnRefreshTokenRevoked(
-    const std::string& account_id) {
+void ProfileSyncService::OnRefreshTokenRevoked(const std::string& account_id) {
   if (account_id == signin_->GetAccountIdToUse()) {
     access_token_.clear();
     UpdateAuthErrorState(
         GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED));
   }
 }
 
 void ProfileSyncService::OnRefreshTokensLoaded() {
   // This notification gets fired when OAuth2TokenService loads the tokens
   // from storage.
@@ skipping 25 matching lines @@
   if (!backend_) {
     if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) {
       // If the backend is already shut down when a DISABLE_SYNC happens,
       // the data directory needs to be cleaned up here.
       sync_thread_->task_runner()->PostTask(
           FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_));
     }
     return;
   }
 
-  if (reason == syncer::ShutdownReason::STOP_SYNC
-      || reason == syncer::ShutdownReason::DISABLE_SYNC) {
+  if (reason == syncer::ShutdownReason::STOP_SYNC ||
+      reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
   // First, we spin down the backend to stop change processing as soon as
   // possible.
   base::Time shutdown_start_time = base::Time::Now();
   backend_->StopSyncingForShutdown();
 
   // Stop all data type controllers, if needed.  Note that until Stop
   // completes, it is possible in theory to have a ChangeProcessor apply a
@@ skipping 134 matching lines @@
 
 void ProfileSyncService::OnUnrecoverableErrorImpl(
     const tracked_objects::Location& from_here,
     const std::string& message,
     bool delete_sync_database) {
   DCHECK(HasUnrecoverableError());
   unrecoverable_error_message_ = message;
   unrecoverable_error_location_ = from_here;
 
   UMA_HISTOGRAM_ENUMERATION(kSyncUnrecoverableErrorHistogram,
-                            unrecoverable_error_reason_,
-                            ERROR_REASON_LIMIT);
+                            unrecoverable_error_reason_, ERROR_REASON_LIMIT);
   std::string location;
   from_here.Write(true, true, &location);
-  LOG(ERROR)
-      << "Unrecoverable error detected at " << location
-      << " -- ProfileSyncService unusable: " << message;
+  LOG(ERROR) << "Unrecoverable error detected at " << location
+             << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ProfileSyncService::ShutdownImpl,
                             sync_enabled_weak_factory_.GetWeakPtr(),
                             delete_sync_database ? syncer::DISABLE_SYNC
                                                  : syncer::STOP_SYNC));
 }
 
 void ProfileSyncService::ReenableDatatype(syncer::ModelType type) {
   if (!backend_initialized_ || !data_type_manager_)
     return;
   data_type_manager_->ReenableType(type);
 }
 
 void ProfileSyncService::UpdateBackendInitUMA(bool success) {
   is_first_time_sync_configure_ = !IsFirstSetupComplete();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
   base::Time on_backend_initialized_time = base::Time::Now();
-  base::TimeDelta delta = on_backend_initialized_time -
-      startup_controller_->start_backend_time();
+  base::TimeDelta delta =
+      on_backend_initialized_time - startup_controller_->start_backend_time();
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 }
 
 void ProfileSyncService::PostBackendInitialization() {
   if (protocol_event_observers_.might_have_observers()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
@@ skipping 50 matching lines @@
     // Keep the directory around for now so that on restart we will retry
     // again and potentially succeed in presence of transient file IO failures
     // or permissions issues, etc.
     //
     // TODO(rlarocque): Consider making this UnrecoverableError less special.
     // Unlike every other UnrecoverableError, it does not delete our sync data.
     // This exception made sense at the time it was implemented, but our new
     // directory corruption recovery mechanism makes it obsolete.  By the time
     // we get here, we will have already tried and failed to delete the
     // directory.  It would be no big deal if we tried to delete it again.
-    OnInternalUnrecoverableError(FROM_HERE,
-                                 "BackendInitialize failure",
-                                 false,
+    OnInternalUnrecoverableError(FROM_HERE, "BackendInitialize failure", false,
                                  ERROR_REASON_BACKEND_INIT_FAILURE);
     return;
   }
 
   backend_initialized_ = true;
 
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
   SigninClient* signin_client = signin_->GetOriginal()->signin_client();
@@ skipping 39 matching lines @@
 
 void ProfileSyncService::UpdateAuthErrorState(const AuthError& error) {
   is_auth_in_progress_ = false;
   last_auth_error_ = error;
 
   NotifyObservers();
 }
 
 namespace {
 
-AuthError ConnectionStatusToAuthError(
-    syncer::ConnectionStatus status) {
+AuthError ConnectionStatusToAuthError(syncer::ConnectionStatus status) {
   switch (status) {
     case syncer::CONNECTION_OK:
       return AuthError::AuthErrorNone();
       break;
     case syncer::CONNECTION_AUTH_ERROR:
       return AuthError(AuthError::INVALID_GAIA_CREDENTIALS);
       break;
     case syncer::CONNECTION_SERVER_ERROR:
       return AuthError(AuthError::CONNECTION_FAILED);
       break;
@@ skipping 30 matching lines @@
     // schedule request if this happens.
     if (request_access_token_retry_timer_.IsRunning()) {
       // The timer to perform a request later is already running; nothing
       // further needs to be done at this point.
     } else if (request_access_token_backoff_.failure_count() == 0) {
       // First time request without delay. Currently invalid token is used
       // to initialize sync backend and we'll always end up here. We don't
       // want to delay initialization.
       request_access_token_backoff_.InformOfRequest(false);
       RequestAccessToken();
-    } else  {
+    } else {
       request_access_token_backoff_.InformOfRequest(false);
       request_access_token_retry_timer_.Start(
           FROM_HERE, request_access_token_backoff_.GetTimeUntilRelease(),
           base::Bind(&ProfileSyncService::RequestAccessToken,
                      sync_enabled_weak_factory_.GetWeakPtr()));
     }
   } else {
     // Reset backoff time after successful connection.
     if (status == syncer::CONNECTION_OK) {
       // Request shouldn't be scheduled at this time. But if it is, it's
@@ skipping 85 matching lines @@
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
-void ProfileSyncService::OnMigrationNeededForTypes(
-    syncer::ModelTypeSet types) {
+void ProfileSyncService::OnMigrationNeededForTypes(syncer::ModelTypeSet types) {
   DCHECK(backend_initialized_);
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   last_actionable_error_ = error;
-  DCHECK_NE(last_actionable_error_.action,
-            syncer::UNKNOWN_ACTION);
+  DCHECK_NE(last_actionable_error_.action, syncer::UNKNOWN_ACTION);
   switch (error.action) {
     case syncer::UPGRADE_CLIENT:
     case syncer::CLEAR_USER_DATA_AND_RESYNC:
     case syncer::ENABLE_SYNC_ON_ACCOUNT:
     case syncer::STOP_AND_RESTART_SYNC:
       // TODO(lipalani) : if setup in progress we want to display these
       // actions in the popup. The current experience might not be optimal for
       // the user. We just dismiss the dialog.
       if (startup_controller_->IsSetupInProgress()) {
         RequestStop(CLEAR_DATA);
         expect_sync_configuration_aborted_ = true;
       }
       // Trigger an unrecoverable error to stop syncing.
       OnInternalUnrecoverableError(FROM_HERE,
                                    last_actionable_error_.error_description,
-                                   true,
-                                   ERROR_REASON_ACTIONABLE_ERROR);
+                                   true, ERROR_REASON_ACTIONABLE_ERROR);
       break;
     case syncer::DISABLE_SYNC_ON_CLIENT:
       if (error.error_type == syncer::NOT_MY_BIRTHDAY) {
         UMA_HISTOGRAM_ENUMERATION("Sync.StopSource", syncer::BIRTHDAY_ERROR,
                                   syncer::STOP_SOURCE_LIMIT);
       }
       RequestStop(CLEAR_DATA);
 #if !defined(OS_CHROMEOS)
       // On every platform except ChromeOS, sign out the user after a dashboard
       // clear.
@@ skipping 70 matching lines @@
   configure_status_ = result.status;
   data_type_status_table_ = result.data_type_status_table;
 
   // We should have cleared our cached passphrase before we get here (in
   // OnBackendInitialized()).
   DCHECK(cached_passphrase_.empty());
 
   if (!sync_configure_start_time_.is_null()) {
     if (result.status == DataTypeManager::OK) {
       base::Time sync_configure_stop_time = base::Time::Now();
-      base::TimeDelta delta = sync_configure_stop_time -
-          sync_configure_start_time_;
+      base::TimeDelta delta =
+          sync_configure_stop_time - sync_configure_start_time_;
       if (is_first_time_sync_configure_) {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceInitialConfigureTime", delta);
       } else {
-        UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceSubsequentConfigureTime",
-                                  delta);
+        UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceSubsequentConfigureTime", delta);
       }
     }
     sync_configure_start_time_ = base::Time();
   }
 
   // Notify listeners that configuration is done.
   FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
                     OnSyncConfigurationCompleted());
 
   DVLOG(1) << "PSS OnConfigureDone called with status: " << configure_status_;
   // The possible status values:
   //    ABORT - Configuration was aborted. This is not an error, if
   //            initiated by user.
   //    OK - Some or all types succeeded.
   //    Everything else is an UnrecoverableError. So treat it as such.
 
   // First handle the abort case.
   if (configure_status_ == DataTypeManager::ABORTED &&
       expect_sync_configuration_aborted_) {
     DVLOG(0) << "ProfileSyncService::Observe Sync Configure aborted";
     expect_sync_configuration_aborted_ = false;
     return;
   }
 
   // Handle unrecoverable error.
   if (configure_status_ != DataTypeManager::OK) {
     // Something catastrophic had happened. We should only have one
     // error representing it.
-    syncer::SyncError error =
-        data_type_status_table_.GetUnrecoverableError();
+    syncer::SyncError error = data_type_status_table_.GetUnrecoverableError();
     DCHECK(error.IsSet());
     std::string message =
         "Sync configuration failed with status " +
         DataTypeManager::ConfigureStatusToString(configure_status_) +
         " caused by " +
         syncer::ModelTypeSetToString(
             data_type_status_table_.GetUnrecoverableErrorTypes()) +
         ": " + error.message();
     LOG(ERROR) << "ProfileSyncService error: " << message;
-    OnInternalUnrecoverableError(error.location(),
-                                 message,
-                                 true,
+    OnInternalUnrecoverableError(error.location(), message, true,
                                  ERROR_REASON_CONFIGURATION_FAILURE);
     return;
   }
 
   DCHECK_EQ(DataTypeManager::OK, configure_status_);
 
   // We should never get in a state where we have no encrypted datatypes
   // enabled, and yet we still think we require a passphrase for decryption.
-  DCHECK(!(IsPassphraseRequiredForDecryption() &&
-           !IsEncryptedDatatypeEnabled()));
+  DCHECK(
+      !(IsPassphraseRequiredForDecryption() && !IsEncryptedDatatypeEnabled()));
 
   // This must be done before we start syncing with the server to avoid
   // sending unencrypted data up on a first time sync.
   if (encryption_pending_)
     backend_->EnableEncryptEverything();
   NotifyObservers();
 
   if (migrator_.get() &&
       migrator_->state() != browser_sync::BackendMigrator::IDLE) {
     // Migration in progress.  Let the migrator know we just finished
@@ skipping 11 matching lines @@
 
   StartSyncingWithServer();
 }
 
 void ProfileSyncService::OnConfigureStart() {
   sync_configure_start_time_ = base::Time::Now();
   NotifyObservers();
 }
 
 ProfileSyncService::SyncStatusSummary
-      ProfileSyncService::QuerySyncStatusSummary() {
+ProfileSyncService::QuerySyncStatusSummary() {
   if (HasUnrecoverableError()) {
     return UNRECOVERABLE_ERROR;
   } else if (!backend_) {
     return NOT_ENABLED;
   } else if (backend_.get() && !IsFirstSetupComplete()) {
     return SETUP_INCOMPLETE;
   } else if (backend_ && IsFirstSetupComplete() && data_type_manager_ &&
              data_type_manager_->state() == DataTypeManager::STOPPED) {
     return DATATYPES_NOT_INITIALIZED;
   } else if (IsSyncActive()) {
     return INITIALIZED;
   }
   return UNKNOWN_ERROR;
 }
 
 std::string ProfileSyncService::QuerySyncStatusSummaryString() {
   SyncStatusSummary status = QuerySyncStatusSummary();
 
   std::string config_status_str =
-      configure_status_ != DataTypeManager::UNKNOWN ?
-          DataTypeManager::ConfigureStatusToString(configure_status_) : "";
+      configure_status_ != DataTypeManager::UNKNOWN
+          ? DataTypeManager::ConfigureStatusToString(configure_status_)
+          : "";
 
   switch (status) {
     case UNRECOVERABLE_ERROR:
       return "Unrecoverable error detected";
     case NOT_ENABLED:
       return "Syncing not enabled";
     case SETUP_INCOMPLETE:
       return "First time sync setup incomplete";
     case DATATYPES_NOT_INITIALIZED:
       return "Datatypes not fully initialized";
@@ skipping 92 matching lines @@
 
 const syncer::Experiments& ProfileSyncService::current_experiments() const {
   return current_experiments_;
 }
 
 bool ProfileSyncService::HasUnrecoverableError() const {
   return unrecoverable_error_reason_ != ERROR_REASON_UNSET;
 }
 
 bool ProfileSyncService::IsPassphraseRequired() const {
-  return passphrase_required_reason_ !=
-      syncer::REASON_PASSPHRASE_NOT_REQUIRED;
+  return passphrase_required_reason_ != syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 }
 
 bool ProfileSyncService::IsPassphraseRequiredForDecryption() const {
   // If there is an encrypted datatype enabled and we don't have the proper
   // passphrase, we must prompt the user for a passphrase. The only way for the
   // user to avoid entering their passphrase is to disable the encrypted types.
   return IsEncryptedDatatypeEnabled() && IsPassphraseRequired();
 }
 
 base::string16 ProfileSyncService::GetLastSyncedTimeString() const {
   const base::Time last_synced_time = sync_prefs_.GetLastSyncedTime();
   if (last_synced_time.is_null())
     return l10n_util::GetStringUTF16(IDS_SYNC_TIME_NEVER);
 
   base::TimeDelta time_since_last_sync = base::Time::Now() - last_synced_time;
 
   if (time_since_last_sync < base::TimeDelta::FromMinutes(1))
     return l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW);
 
   return ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED,
                                 ui::TimeFormat::LENGTH_SHORT,
                                 time_since_last_sync);
 }
 
 void ProfileSyncService::UpdateSelectedTypesHistogram(
-    bool sync_everything, const syncer::ModelTypeSet chosen_types) const {
+    bool sync_everything,
+    const syncer::ModelTypeSet chosen_types) const {
   if (!IsFirstSetupComplete() ||
       sync_everything != sync_prefs_.HasKeepEverythingSynced()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.SyncEverything", sync_everything);
   }
 
   // Only log the data types that are shown in the sync settings ui.
   // Note: the order of these types must match the ordering of
   // the respective types in ModelType
   const sync_driver::user_selectable_type::UserSelectableSyncType
       user_selectable_types[] = {
-    sync_driver::user_selectable_type::BOOKMARKS,
-    sync_driver::user_selectable_type::PREFERENCES,
-    sync_driver::user_selectable_type::PASSWORDS,
-    sync_driver::user_selectable_type::AUTOFILL,
-    sync_driver::user_selectable_type::THEMES,
-    sync_driver::user_selectable_type::TYPED_URLS,
-    sync_driver::user_selectable_type::EXTENSIONS,
-    sync_driver::user_selectable_type::APPS,
-    sync_driver::user_selectable_type::PROXY_TABS,
-  };
+          sync_driver::user_selectable_type::BOOKMARKS,
+          sync_driver::user_selectable_type::PREFERENCES,
+          sync_driver::user_selectable_type::PASSWORDS,
+          sync_driver::user_selectable_type::AUTOFILL,
+          sync_driver::user_selectable_type::THEMES,
+          sync_driver::user_selectable_type::TYPED_URLS,
+          sync_driver::user_selectable_type::EXTENSIONS,
+          sync_driver::user_selectable_type::APPS,
+          sync_driver::user_selectable_type::PROXY_TABS,
+      };
 
   static_assert(38 == syncer::MODEL_TYPE_COUNT,
                 "custom config histogram must be updated");
 
   if (!sync_everything) {
     const syncer::ModelTypeSet current_types = GetPreferredDataTypes();
 
     syncer::ModelTypeSet type_set = syncer::UserSelectableTypes();
     syncer::ModelTypeSet::Iterator it = type_set.First();
 
     DCHECK_EQ(arraysize(user_selectable_types), type_set.Size());
 
     for (size_t i = 0; i < arraysize(user_selectable_types) && it.Good();
          ++i, it.Inc()) {
       const syncer::ModelType type = it.Get();
       if (chosen_types.Has(type) &&
           (!IsFirstSetupComplete() || !current_types.Has(type))) {
         // Selected type has changed - log it.
         UMA_HISTOGRAM_ENUMERATION(
-            "Sync.CustomSync",
-            user_selectable_types[i],
+            "Sync.CustomSync", user_selectable_types[i],
             sync_driver::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
       }
     }
   }
 }
 
 #if defined(OS_CHROMEOS)
 void ProfileSyncService::RefreshSpareBootstrapToken(
     const std::string& passphrase) {
   sync_driver::SystemEncryptor encryptor;
@@ skipping 23 matching lines @@
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
   if (data_type_manager_)
     data_type_manager_->ResetDataTypeErrors();
   ChangePreferredDataTypes(chosen_types);
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
     syncer::ModelTypeSet preferred_types) {
-
   DVLOG(1) << "ChangePreferredDataTypes invoked";
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   // Will only enable those types that are registered and preferred.
   sync_prefs_.SetPreferredDataTypes(registered_types, preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
@@ skipping 131 matching lines @@
 }
 
 bool ProfileSyncService::HasUnsyncedItems() const {
   if (HasSyncingBackend() && backend_initialized_) {
     return backend_->HasUnsyncedItems();
   }
   NOTREACHED();
   return false;
 }
 
-browser_sync::BackendMigrator*
-ProfileSyncService::GetBackendMigratorForTest() {
+browser_sync::BackendMigrator* ProfileSyncService::GetBackendMigratorForTest() {
   return migrator_.get();
 }
 
 void ProfileSyncService::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   if (backend_.get() && backend_initialized_) {
     backend_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
@@ skipping 35 matching lines @@
   result->Append(std::move(type_status_header));
 
   std::unique_ptr<base::DictionaryValue> type_status;
   for (ModelTypeSet::Iterator it = registered.First(); it.Good(); it.Inc()) {
     ModelType type = it.Get();
 
     type_status.reset(new base::DictionaryValue());
     type_status->SetString("name", ModelTypeToString(type));
 
     if (error_map.find(type) != error_map.end()) {
-      const syncer::SyncError &error = error_map.find(type)->second;
+      const syncer::SyncError& error = error_map.find(type)->second;
       DCHECK(error.IsSet());
       switch (error.GetSeverity()) {
-        case syncer::SyncError::SYNC_ERROR_SEVERITY_ERROR: {
-            std::string error_text = "Error: " + error.location().ToString() +
-                ", " + error.GetMessagePrefix() + error.message();
-            type_status->SetString("status", "error");
-            type_status->SetString("value", error_text);
-          }
+        case syncer::SyncError::SYNC_ERROR_SEVERITY_ERROR:
+          type_status->SetString("status", "error");
+          type_status->SetString(
+              "value", "Error: " + error.location().ToString() + ", " +
+                           error.GetMessagePrefix() + error.message());
           break;
         case syncer::SyncError::SYNC_ERROR_SEVERITY_INFO:
           type_status->SetString("status", "disabled");
           type_status->SetString("value", error.message());
           break;
         default:
           NOTREACHED() << "Unexpected error severity.";
           break;
       }
     } else if (syncer::IsProxyType(type) && passive_types.Has(type)) {
       // Show a proxy type in "ok" state unless it is disabled by user.
       DCHECK(!throttled_types.Has(type));
       type_status->SetString("status", "ok");
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type) && passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive, Throttled");
     } else if (passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Throttled");
     } else if (active_types.Has(type)) {
       type_status->SetString("status", "ok");
-      type_status->SetString("value", "Active: " +
-                             ModelSafeGroupToString(routing_info[type]));
+      type_status->SetString(
+          "value", "Active: " + ModelSafeGroupToString(routing_info[type]));
     } else {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Disabled by User");
     }
 
     int live_count = detailed_status.num_entries_by_type[type] -
-        detailed_status.num_to_delete_entries_by_type[type];
+                     detailed_status.num_to_delete_entries_by_type[type];
     type_status->SetInteger("num_entries",
                             detailed_status.num_entries_by_type[type]);
     type_status->SetInteger("num_live", live_count);
 
     result->Append(std::move(type_status));
   }
   return result.release();
 }
 
 void ProfileSyncService::ConsumeCachedPassphraseIfPossible() {
@@ skipping 44 matching lines @@
   token_receive_time_ = base::Time();
   next_token_request_time_ = base::Time();
   access_token_request_ =
       oauth2_token_service_->StartRequest(account_id, oauth2_scopes, this);
 }
 
 void ProfileSyncService::SetEncryptionPassphrase(const std::string& passphrase,
                                                  PassphraseType type) {
   // This should only be called when the backend has been initialized.
   DCHECK(IsBackendInitialized());
-  DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase())) <<
-      "Data is already encrypted using an explicit passphrase";
+  DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase()))
+      << "Data is already encrypted using an explicit passphrase";
   DCHECK(!(type == EXPLICIT &&
-           passphrase_required_reason_ == syncer::REASON_DECRYPTION)) <<
-         "Can not set explicit passphrase when decryption is needed.";
+           passphrase_required_reason_ == syncer::REASON_DECRYPTION))
+      << "Can not set explicit passphrase when decryption is needed.";
 
   DVLOG(1) << "Setting " << (type == EXPLICIT ? "explicit" : "implicit")
            << " passphrase for encryption.";
   if (passphrase_required_reason_ == syncer::REASON_ENCRYPTION) {
     // REASON_ENCRYPTION implies that the cryptographer does not have pending
     // keys. Hence, as long as we're not trying to do an invalid passphrase
     // change (e.g. explicit -> explicit or explicit -> implicit), we know this
     // will succeed. If for some reason a new encryption key arrives via
     // sync later, the SBH will trigger another OnPassphraseRequired().
     passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
@@ skipping 344 matching lines @@
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetDataTypesFromPreferenceProviders()
     const {
   syncer::ModelTypeSet types;
   for (std::set<SyncTypePreferenceProvider*>::const_iterator it =
            preference_providers_.begin();
-       it != preference_providers_.end();
-       ++it) {
+       it != preference_providers_.end(); ++it) {
     types.PutAll((*it)->GetPreferredDataTypes());
   }
   return types;
 }
 
-const DataTypeStatusTable& ProfileSyncService::data_type_status_table()
-    const {
+const DataTypeStatusTable& ProfileSyncService::data_type_status_table() const {
   return data_type_status_table_;
 }
 
 void ProfileSyncService::OnInternalUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message,
     bool delete_sync_database,
     UnrecoverableErrorReason reason) {
   DCHECK(!HasUnrecoverableError());
   unrecoverable_error_reason_ = reason;
@@ skipping 75 matching lines @@
     return NULL;
   }
 }
 
 void ProfileSyncService::RefreshTypesForTest(syncer::ModelTypeSet types) {
   if (backend_initialized_)
     backend_->RefreshTypesForTest(types);
 }
 
 void ProfileSyncService::RemoveClientFromServer() const {
-  if (!backend_initialized_) return;
+  if (!backend_initialized_)
+    return;
   const std::string cache_guid = local_device_->GetLocalSyncCacheGUID();
   std::string birthday;
   syncer::UserShare* user_share = GetUserShare();
   if (user_share && user_share->directory.get()) {
     birthday = user_share->directory->store_birthday();
   }
   if (!access_token_.empty() && !cache_guid.empty() && !birthday.empty()) {
-    sync_stopped_reporter_->ReportSyncStopped(
-        access_token_, cache_guid, birthday);
+    sync_stopped_reporter_->ReportSyncStopped(access_token_, cache_guid,
+                                              birthday);
   }
 }
 
 void ProfileSyncService::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     sync_prefs_.SetMemoryPressureWarningCount(
         sync_prefs_.GetMemoryPressureWarningCount() + 1);
   }
@@ skipping 38 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }