[Sync] Move //components/sync to the syncer namespace.

components/sync/device_info/device_info_service.cc

 // Copyright 2015 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/device_info/device_info_service.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "components/sync/api/entity_change.h"
 #include "components/sync/api/metadata_batch.h"
 #include "components/sync/api/sync_error.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/data_batch_impl.h"
 #include "components/sync/device_info/device_info_util.h"
 #include "components/sync/protocol/data_type_state.pb.h"
 #include "components/sync/protocol/sync.pb.h"
 
-namespace sync_driver_v2 {
+namespace syncer {
 
 using base::Time;
 using base::TimeDelta;
-using syncer::SyncError;
-using syncer_v2::DataBatchImpl;
-using syncer_v2::EntityChange;
-using syncer_v2::EntityChangeList;
-using syncer_v2::EntityData;
-using syncer_v2::EntityDataMap;
-using syncer_v2::MetadataBatch;
-using syncer_v2::MetadataChangeList;
-using syncer_v2::ModelTypeStore;
-using syncer_v2::SimpleMetadataChangeList;
-using sync_driver::DeviceInfo;
-using sync_driver::DeviceInfoUtil;
 using sync_pb::DataTypeState;
 using sync_pb::DeviceInfoSpecifics;
 using sync_pb::EntitySpecifics;
 
 using Record = ModelTypeStore::Record;
 using RecordList = ModelTypeStore::RecordList;
 using Result = ModelTypeStore::Result;
 using WriteBatch = ModelTypeStore::WriteBatch;
 
 DeviceInfoService::DeviceInfoService(
-    sync_driver::LocalDeviceInfoProvider* local_device_info_provider,
+    LocalDeviceInfoProvider* local_device_info_provider,
     const StoreFactoryFunction& callback,
     const ChangeProcessorFactory& change_processor_factory)
-    : ModelTypeService(change_processor_factory, syncer::DEVICE_INFO),
+    : ModelTypeService(change_processor_factory, DEVICE_INFO),
       local_device_info_provider_(local_device_info_provider) {
   DCHECK(local_device_info_provider);
 
   // This is not threadsafe, but presuably the provider initializes on the same
   // thread as us so we're okay.
   if (local_device_info_provider->GetLocalDeviceInfo()) {
     OnProviderInitialized();
   } else {
     subscription_ =
         local_device_info_provider->RegisterOnInitializedCallback(base::Bind(
@@ skipping 38 matching lines @@
         kv.second.value().specifics.device_info();
     DCHECK_EQ(kv.first, specifics.cache_guid());
     if (specifics.cache_guid() == local_guid) {
       // Don't Put local data if it's the same as the remote copy.
       if (local_info->Equals(*CopyToModel(specifics))) {
         local_guids_to_put.erase(local_guid);
       } else {
         // This device is valid right now and this entry is about to be
         // committed, use this as an opportunity to refresh the timestamp.
         all_data_[local_guid]->set_last_updated_timestamp(
-            syncer::TimeToProtoTime(Time::Now()));
+            TimeToProtoTime(Time::Now()));
       }
     } else {
       // Remote data wins conflicts.
       local_guids_to_put.erase(specifics.cache_guid());
       has_changes = true;
       StoreSpecifics(base::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
     }
   }
 
@@ skipping 65 matching lines @@
   }
 
   callback.Run(SyncError(), std::move(batch));
 }
 
 std::string DeviceInfoService::GetClientTag(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return DeviceInfoUtil::SpecificsToTag(entity_data.specifics.device_info());
 }
 
-std::string DeviceInfoService::GetStorageKey(
-    const syncer_v2::EntityData& entity_data) {
+std::string DeviceInfoService::GetStorageKey(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return entity_data.specifics.device_info().cache_guid();
 }
 
 void DeviceInfoService::OnChangeProcessorSet() {
   // We've recieved a new processor that needs metadata. If we're still in the
   // process of loading data and/or metadata, then |has_metadata_loaded_| is
   // false and we'll wait for those async reads to happen. If we've already
   // loaded metadata and then subsequently we get a new processor, we must not
   // have created the processor ourselves because we had no metadata. So there
@@ skipping 257 matching lines @@
 void DeviceInfoService::SendLocalData() {
   DCHECK(has_provider_initialized_);
   // TODO(skym): Handle disconnecting and reconnecting, this will currently halt
   // the pulse timer and never restart it.
   if (!change_processor()) {
     return;
   }
 
   std::unique_ptr<DeviceInfoSpecifics> specifics =
       CopyToSpecifics(*local_device_info_provider_->GetLocalDeviceInfo());
-  specifics->set_last_updated_timestamp(syncer::TimeToProtoTime(Time::Now()));
+  specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
 
   std::unique_ptr<MetadataChangeList> metadata_change_list =
       CreateMetadataChangeList();
   change_processor()->Put(specifics->cache_guid(), CopyToEntityData(*specifics),
                           metadata_change_list.get());
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   StoreSpecifics(std::move(specifics), batch.get());
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list), true);
@@ skipping 33 matching lines @@
     CreateChangeProcessor();
   }
   change_processor()->OnMetadataLoaded(
       change_processor()->CreateAndUploadError(FROM_HERE, msg), nullptr);
 }
 
 // static
 Time DeviceInfoService::GetLastUpdateTime(
     const DeviceInfoSpecifics& specifics) {
   if (specifics.has_last_updated_timestamp()) {
-    return syncer::ProtoTimeToTime(specifics.last_updated_timestamp());
+    return ProtoTimeToTime(specifics.last_updated_timestamp());
   } else {
     return Time();
   }
 }
 
-}  // namespace sync_driver_v2
+}  // namespace syncer