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

components/sync/core_impl/sync_manager_impl.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 "sync/internal_api/sync_manager_impl.h"
+#include "components/sync/core_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
-#include "sync/engine/sync_scheduler.h"
-#include "sync/engine/syncer_types.h"
-#include "sync/internal_api/change_reorder_buffer.h"
-#include "sync/internal_api/model_type_connector_proxy.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/internal_api/public/base/invalidation_interface.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base_node.h"
-#include "sync/internal_api/public/configure_reason.h"
-#include "sync/internal_api/public/engine/polling_constants.h"
-#include "sync/internal_api/public/http_post_provider_factory.h"
-#include "sync/internal_api/public/internal_components_factory.h"
-#include "sync/internal_api/public/read_node.h"
-#include "sync/internal_api/public/read_transaction.h"
-#include "sync/internal_api/public/user_share.h"
-#include "sync/internal_api/public/util/experiments.h"
-#include "sync/internal_api/public/write_node.h"
-#include "sync/internal_api/public/write_transaction.h"
-#include "sync/internal_api/syncapi_internal.h"
-#include "sync/internal_api/syncapi_server_connection_manager.h"
-#include "sync/protocol/proto_value_conversions.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/sessions/directory_type_debug_info_emitter.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/in_memory_directory_backing_store.h"
-#include "sync/syncable/on_disk_directory_backing_store.h"
+#include "components/sync/base/cancelation_signal.h"
+#include "components/sync/base/experiments.h"
+#include "components/sync/base/invalidation_interface.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/core/base_node.h"
+#include "components/sync/core/configure_reason.h"
+#include "components/sync/core/http_post_provider_factory.h"
+#include "components/sync/core/internal_components_factory.h"
+#include "components/sync/core/read_node.h"
+#include "components/sync/core/read_transaction.h"
+#include "components/sync/core/user_share.h"
+#include "components/sync/core/write_node.h"
+#include "components/sync/core/write_transaction.h"
+#include "components/sync/core_impl/change_reorder_buffer.h"
+#include "components/sync/core_impl/model_type_connector_proxy.h"
+#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/core_impl/syncapi_server_connection_manager.h"
+#include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine_impl/sync_scheduler.h"
+#include "components/sync/engine_impl/syncer_types.h"
+#include "components/sync/protocol/proto_value_conversions.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/sessions_impl/directory_type_debug_info_emitter.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/in_memory_directory_backing_store.h"
+#include "components/sync/syncable/on_disk_directory_backing_store.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
 
 class GURL;
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
@@ skipping 76 matching lines @@
   DCHECK_EQ(GetModelTypeFromSpecifics(a_specifics),
             GetModelTypeFromSpecifics(b_specifics));
   ModelType model_type = GetModelTypeFromSpecifics(b_specifics);
   // Suppress updates to items that aren't tracked by any browser model.
   if (model_type < FIRST_REAL_MODEL_TYPE ||
       !a.ref(syncable::UNIQUE_SERVER_TAG).empty()) {
     return false;
   }
   if (a.ref(syncable::IS_DIR) != b.ref(syncable::IS_DIR))
     return true;
-  if (!AreSpecificsEqual(cryptographer,
-                         a.ref(syncable::SPECIFICS),
+  if (!AreSpecificsEqual(cryptographer, a.ref(syncable::SPECIFICS),
                          b.ref(syncable::SPECIFICS))) {
     return true;
   }
   if (!AreAttachmentMetadataEqual(a.ref(syncable::ATTACHMENT_METADATA),
                                   b.ref(syncable::ATTACHMENT_METADATA))) {
     return true;
   }
   // We only care if the name has changed if neither specifics is encrypted
   // (encrypted nodes blow away the NON_UNIQUE_NAME).
   if (!a_specifics.has_encrypted() && !b_specifics.has_encrypted() &&
@@ skipping 29 matching lines @@
     ModelTypeSet to_journal,
     ModelTypeSet to_unapply,
     const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!ready_task.is_null());
   DCHECK(initialized_);
 
   DVLOG(1) << "Configuring -"
-           << "\n\t" << "current types: "
+           << "\n\t"
+           << "current types: "
            << ModelTypeSetToString(GetRoutingInfoTypes(new_routing_info))
-           << "\n\t" << "types to download: "
-           << ModelTypeSetToString(to_download)
-           << "\n\t" << "types to purge: "
-           << ModelTypeSetToString(to_purge)
-           << "\n\t" << "types to journal: "
-           << ModelTypeSetToString(to_journal)
-           << "\n\t" << "types to unapply: "
-           << ModelTypeSetToString(to_unapply);
-  if (!PurgeDisabledTypes(to_purge,
-                          to_journal,
-                          to_unapply)) {
+           << "\n\t"
+           << "types to download: " << ModelTypeSetToString(to_download)
+           << "\n\t"
+           << "types to purge: " << ModelTypeSetToString(to_purge) << "\n\t"
+           << "types to journal: " << ModelTypeSetToString(to_journal) << "\n\t"
+           << "types to unapply: " << ModelTypeSetToString(to_unapply);
+  if (!PurgeDisabledTypes(to_purge, to_journal, to_unapply)) {
     // We failed to cleanup the types. Invoke the ready task without actually
     // configuring any types. The caller should detect this as a configuration
     // failure and act appropriately.
     ready_task.Run();
     return;
   }
 
-  ConfigurationParams params(GetSourceFromReason(reason),
-                             to_download,
-                             new_routing_info,
-                             ready_task,
-                             retry_task);
+  ConfigurationParams params(GetSourceFromReason(reason), to_download,
+                             new_routing_info, ready_task, retry_task);
 
   scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
   scheduler_->ScheduleConfiguration(params);
 }
 
 void SyncManagerImpl::Init(InitArgs* args) {
   CHECK(!initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(args->post_factory.get());
   DCHECK(!args->credentials.account_id.empty());
@@ skipping 27 matching lines @@
 
   base::FilePath absolute_db_path = database_path_;
   DCHECK(absolute_db_path.IsAbsolute());
 
   std::unique_ptr<syncable::DirectoryBackingStore> backing_store =
       args->internal_components_factory->BuildDirectoryBackingStore(
           InternalComponentsFactory::STORAGE_ON_DISK,
           args->credentials.account_id, absolute_db_path);
 
   DCHECK(backing_store.get());
-  share_.directory.reset(
-      new syncable::Directory(
-          backing_store.release(),
-          args->unrecoverable_error_handler,
-          report_unrecoverable_error_function_,
-          sync_encryption_handler_.get(),
-          sync_encryption_handler_->GetCryptographerUnsafe()));
+  share_.directory.reset(new syncable::Directory(
+      backing_store.release(), args->unrecoverable_error_handler,
+      report_unrecoverable_error_function_, sync_encryption_handler_.get(),
+      sync_encryption_handler_->GetCryptographerUnsafe()));
   share_.sync_credentials = args->credentials;
 
   // UserShare is accessible to a lot of code that doesn't need access to the
   // sync token so clear sync_token from the UserShare.
   share_.sync_credentials.sync_token = "";
 
   DVLOG(1) << "Username: " << args->credentials.email;
   DVLOG(1) << "AccountId: " << args->credentials.account_id;
   if (!OpenDirectory(args->credentials.account_id)) {
     NotifyInitializationFailure();
@@ skipping 104 matching lines @@
 
 void SyncManagerImpl::OnPassphraseTypeChanged(
     PassphraseType type,
     base::Time explicit_passphrase_time) {
   allstatus_.SetPassphraseType(type);
   allstatus_.SetKeystoreMigrationTime(
       sync_encryption_handler_->migration_time());
 }
 
 void SyncManagerImpl::OnLocalSetPassphraseEncryption(
-    const SyncEncryptionHandler::NigoriState& nigori_state) {
-}
+    const SyncEncryptionHandler::NigoriState& nigori_state) {}
 
 void SyncManagerImpl::StartSyncingNormally(
     const ModelSafeRoutingInfo& routing_info,
     base::Time last_poll_time) {
   // Start the sync scheduler.
   // TODO(sync): We always want the newest set of routes when we switch back
   // to normal mode. Figure out how to enforce set_routing_info is always
   // appropriately set and that it's only modified when switching to normal
   // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
   session_context_->SetRoutingInfo(routing_info);
-  scheduler_->Start(SyncScheduler::NORMAL_MODE,
-                    last_poll_time);
+  scheduler_->Start(SyncScheduler::NORMAL_MODE, last_poll_time);
 }
 
 syncable::Directory* SyncManagerImpl::directory() {
   return share_.directory.get();
 }
 
 const SyncScheduler* SyncManagerImpl::scheduler() const {
   return scheduler_.get();
 }
 
@@ skipping 29 matching lines @@
   // part of initialization.
   if (!PurgePartiallySyncedTypes())
     return false;
 
   return true;
 }
 
 bool SyncManagerImpl::PurgePartiallySyncedTypes() {
   ModelTypeSet partially_synced_types = ModelTypeSet::All();
   partially_synced_types.RemoveAll(directory()->InitialSyncEndedTypes());
-  partially_synced_types.RemoveAll(GetTypesWithEmptyProgressMarkerToken(
-      ModelTypeSet::All()));
+  partially_synced_types.RemoveAll(
+      GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All()));
 
   DVLOG(1) << "Purging partially synced types "
            << ModelTypeSetToString(partially_synced_types);
   UMA_HISTOGRAM_COUNTS("Sync.PartiallySyncedTypes",
                        partially_synced_types.Size());
   if (partially_synced_types.Empty())
     return true;
   return directory()->PurgeEntriesWithTypeIn(partially_synced_types,
-                                             ModelTypeSet(),
-                                             ModelTypeSet());
+                                             ModelTypeSet(), ModelTypeSet());
 }
 
-bool SyncManagerImpl::PurgeDisabledTypes(
-    ModelTypeSet to_purge,
-    ModelTypeSet to_journal,
-    ModelTypeSet to_unapply) {
+bool SyncManagerImpl::PurgeDisabledTypes(ModelTypeSet to_purge,
+                                         ModelTypeSet to_journal,
+                                         ModelTypeSet to_unapply) {
   if (to_purge.Empty())
     return true;
   DVLOG(1) << "Purging disabled types " << ModelTypeSetToString(to_purge);
   DCHECK(to_purge.HasAll(to_journal));
   DCHECK(to_purge.HasAll(to_unapply));
   return directory()->PurgeEntriesWithTypeIn(to_purge, to_journal, to_unapply);
 }
 
 void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 79 matching lines @@
 void SyncManagerImpl::OnIPAddressChanged() {
   if (!observing_network_connectivity_changes_) {
     DVLOG(1) << "IP address change dropped.";
     return;
   }
   DVLOG(1) << "IP address change detected.";
   OnNetworkConnectivityChangedImpl();
 }
 
 void SyncManagerImpl::OnConnectionTypeChanged(
-  net::NetworkChangeNotifier::ConnectionType) {
+    net::NetworkChangeNotifier::ConnectionType) {
   if (!observing_network_connectivity_changes_) {
     DVLOG(1) << "Connection type change dropped.";
     return;
   }
   DVLOG(1) << "Connection type change detected.";
   OnNetworkConnectivityChangedImpl();
 }
 
 void SyncManagerImpl::OnNetworkConnectivityChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->OnConnectionStatusChange();
 }
 
 void SyncManagerImpl::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (event.connection_code ==
-      HttpResponse::SERVER_CONNECTION_OK) {
+  if (event.connection_code == HttpResponse::SERVER_CONNECTION_OK) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_OK));
   }
 
   if (event.connection_code == HttpResponse::SYNC_AUTH_ERROR) {
     observing_network_connectivity_changes_ = false;
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_AUTH_ERROR));
   }
 
   if (event.connection_code == HttpResponse::SYNC_SERVER_ERROR) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_SERVER_ERROR));
   }
 }
 
 void SyncManagerImpl::HandleTransactionCompleteChangeEvent(
     ModelTypeSet models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
   if (!change_delegate_)
     return;
 
   // Call commit.
-  for (ModelTypeSet::Iterator it = models_with_changes.First();
-       it.Good(); it.Inc()) {
+  for (ModelTypeSet::Iterator it = models_with_changes.First(); it.Good();
+       it.Inc()) {
     change_delegate_->OnChangesComplete(it.Get());
     change_observer_.Call(
-        FROM_HERE,
-        &SyncManager::ChangeObserver::OnChangesComplete,
-        it.Get());
+        FROM_HERE, &SyncManager::ChangeObserver::OnChangesComplete, it.Get());
   }
 }
 
-ModelTypeSet
-SyncManagerImpl::HandleTransactionEndingChangeEvent(
+ModelTypeSet SyncManagerImpl::HandleTransactionEndingChangeEvent(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // This notification happens immediately before a syncable WriteTransaction
   // falls out of scope. It happens while the channel mutex is still held,
   // and while the transaction mutex is held, so it cannot be re-entrant.
   if (!change_delegate_ || change_records_.empty())
     return ModelTypeSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
   // that's closing. This special ReadTransaction will not close the
   // underlying transaction.
   ReadTransaction read_trans(GetUserShare(), trans);
 
   ModelTypeSet models_with_changes;
   for (ChangeRecordMap::const_iterator it = change_records_.begin();
-      it != change_records_.end(); ++it) {
+       it != change_records_.end(); ++it) {
     DCHECK(!it->second.Get().empty());
     ModelType type = ModelTypeFromInt(it->first);
-    change_delegate_->
-        OnChangesApplied(type, trans->directory()->GetTransactionVersion(type),
-                         &read_trans, it->second);
+    change_delegate_->OnChangesApplied(
+        type, trans->directory()->GetTransactionVersion(type), &read_trans,
+        it->second);
     change_observer_.Call(FROM_HERE,
-        &SyncManager::ChangeObserver::OnChangesApplied,
-        type, write_transaction_info.Get().id, it->second);
+                          &SyncManager::ChangeObserver::OnChangesApplied, type,
+                          write_transaction_info.Get().id, it->second);
     models_with_changes.Put(type);
   }
   change_records_.clear();
   return models_with_changes;
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncApi(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans,
     std::vector<int64_t>* entries_changed) {
   // We have been notified about a user action changing a sync model.
-  LOG_IF(WARNING, !change_records_.empty()) <<
-      "CALCULATE_CHANGES called with unapplied old changes.";
+  LOG_IF(WARNING, !change_records_.empty())
+      << "CALCULATE_CHANGES called with unapplied old changes.";
 
   // The mutated model type, or UNSPECIFIED if nothing was mutated.
   ModelTypeSet mutated_model_types;
 
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
-           mutations.Get().begin(); it != mutations.Get().end(); ++it) {
+           mutations.Get().begin();
+       it != mutations.Get().end(); ++it) {
     if (!it->second.mutated.ref(syncable::IS_UNSYNCED)) {
       continue;
     }
 
     ModelType model_type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (model_type < FIRST_REAL_MODEL_TYPE) {
       NOTREACHED() << "Permanent or underspecified item changed via syncapi.";
       continue;
     }
 
     // Found real mutation.
     if (model_type != UNSPECIFIED) {
       mutated_model_types.Put(model_type);
       entries_changed->push_back(it->second.mutated.ref(syncable::META_HANDLE));
     }
   }
 
   // Nudge if necessary.
   if (!mutated_model_types.Empty()) {
     if (weak_handle_this_.IsInitialized()) {
       weak_handle_this_.Call(FROM_HERE,
                              &SyncManagerImpl::RequestNudgeForDataTypes,
-                             FROM_HERE,
-                             mutated_model_types);
+                             FROM_HERE, mutated_model_types);
     } else {
       NOTREACHED();
     }
   }
 }
 
 void SyncManagerImpl::SetExtraChangeRecordData(
     int64_t id,
     ModelType type,
     ChangeReorderBuffer* buffer,
@@ skipping 26 matching lines @@
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncer(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans,
     std::vector<int64_t>* entries_changed) {
   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
-  LOG_IF(WARNING, !change_records_.empty()) <<
-      "CALCULATE_CHANGES called with unapplied old changes.";
+  LOG_IF(WARNING, !change_records_.empty())
+      << "CALCULATE_CHANGES called with unapplied old changes.";
 
   ChangeReorderBuffer change_buffers[MODEL_TYPE_COUNT];
 
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
-           mutations.Get().begin(); it != mutations.Get().end(); ++it) {
+           mutations.Get().begin();
+       it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
 
     // Omit items that aren't associated with a model.
     ModelType type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (type < FIRST_REAL_MODEL_TYPE)
       continue;
 
     int64_t handle = it->first;
@@ skipping 62 matching lines @@
       return;
     }
 
     DVLOG(1) << "Sending OnSyncCycleCompleted";
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnSyncCycleCompleted(event.snapshot));
   }
 }
 
 void SyncManagerImpl::OnActionableError(const SyncProtocolError& error) {
-  FOR_EACH_OBSERVER(
-      SyncManager::Observer, observers_,
-      OnActionableError(error));
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+                    OnActionableError(error));
 }
 
 void SyncManagerImpl::OnRetryTimeChanged(base::Time) {}
 
 void SyncManagerImpl::OnThrottledTypesChanged(ModelTypeSet) {}
 
 void SyncManagerImpl::OnMigrationRequested(ModelTypeSet types) {
-  FOR_EACH_OBSERVER(
-      SyncManager::Observer, observers_,
-      OnMigrationRequested(types));
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+                    OnMigrationRequested(types));
 }
 
 void SyncManagerImpl::OnProtocolEvent(const ProtocolEvent& event) {
   protocol_event_buffer_.RecordProtocolEvent(event);
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnProtocolEvent(event));
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_, OnProtocolEvent(event));
 }
 
 void SyncManagerImpl::SetJsEventHandler(
     const WeakHandle<JsEventHandler>& event_handler) {
   js_sync_manager_observer_.SetJsEventHandler(event_handler);
   js_mutation_event_observer_.SetJsEventHandler(event_handler);
   js_sync_encryption_handler_observer_.SetJsEventHandler(event_handler);
 }
 
 std::unique_ptr<base::ListValue> SyncManagerImpl::GetAllNodesForType(
@@ skipping 29 matching lines @@
   allstatus_.IncrementNotificationsReceived();
   scheduler_->ScheduleInvalidationNudge(type, std::move(invalidation),
                                         FROM_HERE);
 }
 
 void SyncManagerImpl::RefreshTypes(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (types.Empty()) {
     LOG(WARNING) << "Sync received refresh request with no types specified.";
   } else {
-    scheduler_->ScheduleLocalRefreshRequest(
-        types, FROM_HERE);
+    scheduler_->ScheduleLocalRefreshRequest(types, FROM_HERE);
   }
 }
 
 SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return allstatus_.status();
 }
 
 void SyncManagerImpl::SaveChanges() {
   directory()->SaveChanges();
 }
@@ skipping 19 matching lines @@
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode nigori_node(&trans);
   if (nigori_node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   bool found_experiment = false;
 
   ReadNode favicon_sync_node(&trans);
   if (favicon_sync_node.InitByClientTagLookup(
-          syncer::EXPERIMENTS,
-          syncer::kFaviconSyncTag) == BaseNode::INIT_OK) {
+          syncer::EXPERIMENTS, syncer::kFaviconSyncTag) == BaseNode::INIT_OK) {
     experiments->favicon_sync_limit =
-        favicon_sync_node.GetExperimentsSpecifics().favicon_sync().
-            favicon_sync_limit();
+        favicon_sync_node.GetExperimentsSpecifics()
+            .favicon_sync()
+            .favicon_sync_limit();
     found_experiment = true;
   }
 
   ReadNode pre_commit_update_avoidance_node(&trans);
   if (pre_commit_update_avoidance_node.InitByClientTagLookup(
-          syncer::EXPERIMENTS,
-          syncer::kPreCommitUpdateAvoidanceTag) == BaseNode::INIT_OK) {
+          syncer::EXPERIMENTS, syncer::kPreCommitUpdateAvoidanceTag) ==
+      BaseNode::INIT_OK) {
     session_context_->set_server_enabled_pre_commit_update_avoidance(
-        pre_commit_update_avoidance_node.GetExperimentsSpecifics().
-            pre_commit_update_avoidance().enabled());
+        pre_commit_update_avoidance_node.GetExperimentsSpecifics()
+            .pre_commit_update_avoidance()
+            .enabled());
     // We don't bother setting found_experiment.  The frontend doesn't need to
     // know about this.
   }
 
   ReadNode gcm_invalidations_node(&trans);
   if (gcm_invalidations_node.InitByClientTagLookup(
           syncer::EXPERIMENTS, syncer::kGCMInvalidationsTag) ==
       BaseNode::INIT_OK) {
     const sync_pb::GcmInvalidationsFlags& gcm_invalidations =
         gcm_invalidations_node.GetExperimentsSpecifics().gcm_invalidations();
     if (gcm_invalidations.has_enabled()) {
       experiments->gcm_invalidations_enabled = gcm_invalidations.enabled();
       found_experiment = true;
     }
   }
 
   return found_experiment;
 }
 
 bool SyncManagerImpl::HasUnsyncedItems() {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
 SyncEncryptionHandler* SyncManagerImpl::GetEncryptionHandler() {
   return sync_encryption_handler_.get();
 }
 
 ScopedVector<syncer::ProtocolEvent>
-    SyncManagerImpl::GetBufferedProtocolEvents() {
+SyncManagerImpl::GetBufferedProtocolEvents() {
   return protocol_event_buffer_.GetBufferedProtocolEvents();
 }
 
 void SyncManagerImpl::RegisterDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) {
   model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(observer);
 }
 
 void SyncManagerImpl::UnregisterDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) {
@@ skipping 17 matching lines @@
 }
 
 void SyncManagerImpl::OnCookieJarChanged(bool account_mismatch,
                                          bool empty_jar) {
   DCHECK(thread_checker_.CalledOnValidThread());
   session_context_->set_cookie_jar_mismatch(account_mismatch);
   session_context_->set_cookie_jar_empty(empty_jar);
 }
 
 }  // namespace syncer