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

components/sync/driver/device_info_sync_service.cc

 // Copyright 2014 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/device_info_sync_service.h"
+#include "components/sync/driver/device_info_sync_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "components/sync/api/sync_change.h"
 #include "components/sync/base/time.h"
+#include "components/sync/driver/device_info_util.h"
+#include "components/sync/driver/local_device_info_provider.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/sync_driver/device_info_util.h"
-#include "components/sync_driver/local_device_info_provider.h"
 
 namespace sync_driver {
 
 using base::Time;
 using base::TimeDelta;
 using syncer::ModelType;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 using syncer::SyncChangeProcessor;
 using syncer::SyncData;
 using syncer::SyncDataList;
 using syncer::SyncErrorFactory;
 using syncer::SyncMergeResult;
 
 DeviceInfoSyncService::DeviceInfoSyncService(
     LocalDeviceInfoProvider* local_device_info_provider)
     : local_device_info_provider_(local_device_info_provider) {
   DCHECK(local_device_info_provider);
 }
 
-DeviceInfoSyncService::~DeviceInfoSyncService() {
-}
+DeviceInfoSyncService::~DeviceInfoSyncService() {}
 
 SyncMergeResult DeviceInfoSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     std::unique_ptr<SyncChangeProcessor> sync_processor,
     std::unique_ptr<SyncErrorFactory> error_handler) {
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
   DCHECK_EQ(type, syncer::DEVICE_INFO);
 
@@ skipping 12 matching lines @@
   // |change_type| defaults to ADD and might be changed to
   // UPDATE to INVALID down below if the initial data contains
   // data matching the local device ID.
   SyncChange::SyncChangeType change_type = SyncChange::ACTION_ADD;
   TimeDelta pulse_delay;
   size_t num_items_new = 0;
   size_t num_items_updated = 0;
 
   // Iterate over all initial sync data and copy it to the cache.
   for (SyncDataList::const_iterator iter = initial_sync_data.begin();
-       iter != initial_sync_data.end();
-       ++iter) {
+       iter != initial_sync_data.end(); ++iter) {
     DCHECK_EQ(syncer::DEVICE_INFO, iter->GetDataType());
 
     const std::string& id = iter->GetSpecifics().device_info().cache_guid();
 
     if (id == local_device_info->guid()) {
       // |initial_sync_data| contains data matching the local device.
       std::unique_ptr<DeviceInfo> synced_local_device_info =
           base::WrapUnique(CreateDeviceInfo(*iter));
 
       pulse_delay = DeviceInfoUtil::CalculatePulseDelay(
@@ skipping 59 matching lines @@
   if (was_syncing) {
     NotifyObservers();
   }
 }
 
 SyncDataList DeviceInfoSyncService::GetAllSyncData(
     syncer::ModelType type) const {
   SyncDataList list;
 
   for (SyncDataMap::const_iterator iter = all_data_.begin();
-       iter != all_data_.end();
-       ++iter) {
+       iter != all_data_.end(); ++iter) {
     list.push_back(iter->second);
   }
 
   return list;
 }
 
 syncer::SyncError DeviceInfoSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   syncer::SyncError error;
 
   DCHECK(local_device_info_provider_->GetLocalDeviceInfo());
   const std::string& local_device_id =
       local_device_info_provider_->GetLocalDeviceInfo()->guid();
 
   bool has_changes = false;
 
   // Iterate over all chanages and merge entries.
   for (SyncChangeList::const_iterator iter = change_list.begin();
-       iter != change_list.end();
-       ++iter) {
+       iter != change_list.end(); ++iter) {
     const SyncData& sync_data = iter->sync_data();
     DCHECK_EQ(syncer::DEVICE_INFO, sync_data.GetDataType());
 
     const std::string& client_id =
         sync_data.GetSpecifics().device_info().cache_guid();
     // Ignore device info matching the local device.
     if (local_device_id == client_id) {
       DVLOG(1) << "Ignoring sync changes for the local DEVICE_INFO";
       continue;
     }
@@ skipping 24 matching lines @@
     return std::unique_ptr<DeviceInfo>();
   }
 
   return base::WrapUnique(CreateDeviceInfo(iter->second));
 }
 
 ScopedVector<DeviceInfo> DeviceInfoSyncService::GetAllDeviceInfo() const {
   ScopedVector<DeviceInfo> list;
 
   for (SyncDataMap::const_iterator iter = all_data_.begin();
-       iter != all_data_.end();
-       ++iter) {
+       iter != all_data_.end(); ++iter) {
     list.push_back(CreateDeviceInfo(iter->second));
   }
 
   return list;
 }
 
 void DeviceInfoSyncService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 29 matching lines @@
   const sync_pb::DeviceInfoSpecifics& specifics = entity.device_info();
   return SyncData::CreateLocalData(DeviceInfoUtil::SpecificsToTag(specifics),
                                    specifics.client_name(), entity);
 }
 
 DeviceInfo* DeviceInfoSyncService::CreateDeviceInfo(
     const syncer::SyncData& sync_data) {
   const sync_pb::DeviceInfoSpecifics& specifics =
       sync_data.GetSpecifics().device_info();
 
-  return new DeviceInfo(specifics.cache_guid(),
-                        specifics.client_name(),
-                        specifics.chrome_version(),
-                        specifics.sync_user_agent(),
+  return new DeviceInfo(specifics.cache_guid(), specifics.client_name(),
+                        specifics.chrome_version(), specifics.sync_user_agent(),
                         specifics.device_type(),
                         specifics.signin_scoped_device_id());
 }
 
 void DeviceInfoSyncService::StoreSyncData(const std::string& client_id,
                                           const SyncData& sync_data) {
   DVLOG(1) << "Storing DEVICE_INFO for "
            << sync_data.GetSpecifics().device_info().client_name()
            << " with ID " << client_id;
   all_data_[client_id] = sync_data;
@@ skipping 47 matching lines @@
     return syncer::SyncDataRemote(device_info).GetModifiedTime();
   } else {
     // We shouldn't reach this point for remote data, so this means we're likely
     // looking at the local device info. Using a long ago time is perfect, since
     // the desired behavior is to update/pulse our data as soon as possible.
     return Time();
   }
 }
 
 }  // namespace sync_driver