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

components/sync/driver/backend_migrator.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/backend_migrator.h"
+#include "components/sync/driver/backend_migrator.h"
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "components/sync/core/configure_reason.h"
 #include "components/sync/core/read_transaction.h"
+#include "components/sync/driver/sync_service.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/syncable/directory.h"  // TODO(tim): Bug 131130.
-#include "components/sync_driver/sync_service.h"
 
 using syncer::ModelTypeSet;
 
 namespace browser_sync {
 
 using syncer::ModelTypeToString;
 
 MigrationObserver::~MigrationObserver() {}
 
 BackendMigrator::BackendMigrator(const std::string& name,
                                  syncer::UserShare* user_share,
                                  sync_driver::SyncService* service,
                                  sync_driver::DataTypeManager* manager,
-                                 const base::Closure &migration_done_callback)
-    : name_(name), user_share_(user_share), service_(service),
-      manager_(manager), state_(IDLE),
+                                 const base::Closure& migration_done_callback)
+    : name_(name),
+      user_share_(user_share),
+      service_(service),
+      manager_(manager),
+      state_(IDLE),
       migration_done_callback_(migration_done_callback),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
-BackendMigrator::~BackendMigrator() {
-}
+BackendMigrator::~BackendMigrator() {}
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncer threads involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 void BackendMigrator::MigrateTypes(syncer::ModelTypeSet types) {
   const ModelTypeSet old_to_migrate = to_migrate_;
   to_migrate_.PutAll(types);
   SDVLOG(1) << "MigrateTypes called with " << ModelTypeSetToString(types)
-           << ", old_to_migrate = " << ModelTypeSetToString(old_to_migrate)
-          << ", to_migrate_ = " << ModelTypeSetToString(to_migrate_);
+            << ", old_to_migrate = " << ModelTypeSetToString(old_to_migrate)
+            << ", to_migrate_ = " << ModelTypeSetToString(to_migrate_);
   if (old_to_migrate == to_migrate_) {
     SDVLOG(1) << "MigrateTypes called with no new types; ignoring";
     return;
   }
 
   if (state_ == IDLE)
     ChangeState(WAITING_TO_START);
 
   if (state_ == WAITING_TO_START) {
     if (!TryStart())
@@ skipping 54 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&BackendMigrator::OnConfigureDoneImpl,
                             weak_ptr_factory_.GetWeakPtr(), result));
 }
 
 namespace {
 
 syncer::ModelTypeSet GetUnsyncedDataTypes(syncer::UserShare* user_share) {
   syncer::ReadTransaction trans(FROM_HERE, user_share);
   syncer::ModelTypeSet unsynced_data_types;
-  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
-       i < syncer::MODEL_TYPE_COUNT; ++i) {
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE; i < syncer::MODEL_TYPE_COUNT;
+       ++i) {
     syncer::ModelType type = syncer::ModelTypeFromInt(i);
     sync_pb::DataTypeProgressMarker progress_marker;
     trans.GetDirectory()->GetDownloadProgress(type, &progress_marker);
     if (progress_marker.token().empty()) {
       unsynced_data_types.Put(type);
     }
   }
   return unsynced_data_types;
 }
 
 }  // namespace
 
 void BackendMigrator::OnConfigureDoneImpl(
     const sync_driver::DataTypeManager::ConfigureResult& result) {
   SDVLOG(1) << "OnConfigureDone with requested types "
-            << ModelTypeSetToString(result.requested_types)
-            << ", status " << result.status
+            << ModelTypeSetToString(result.requested_types) << ", status "
+            << result.status
             << ", and to_migrate_ = " << ModelTypeSetToString(to_migrate_);
   if (state_ == WAITING_TO_START) {
     if (!TryStart())
       SDVLOG(1) << "Manager still not configured; still waiting";
     return;
   }
 
   DCHECK_GT(state_, WAITING_TO_START);
 
   const ModelTypeSet intersection =
@@ skipping 58 matching lines @@
 
 syncer::ModelTypeSet BackendMigrator::GetPendingMigrationTypesForTest() const {
   return to_migrate_;
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 };  // namespace browser_sync