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

components/sync/api/sync_data.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/api/sync_data.h"
 
 #include <algorithm>
 #include <ostream>
 
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "components/sync/core/base_node.h"
 #include "components/sync/protocol/proto_value_conversions.h"
 #include "components/sync/protocol/sync.pb.h"
 
+namespace syncer {
 namespace {
 
-sync_pb::AttachmentIdProto IdToProto(
-    const syncer::AttachmentId& attachment_id) {
+sync_pb::AttachmentIdProto IdToProto(const AttachmentId& attachment_id) {
   return attachment_id.GetProto();
 }
 
-syncer::AttachmentId ProtoToId(const sync_pb::AttachmentIdProto& proto) {
-  return syncer::AttachmentId::CreateFromProto(proto);
+AttachmentId ProtoToId(const sync_pb::AttachmentIdProto& proto) {
+  return AttachmentId::CreateFromProto(proto);
 }
 
 // Return true iff |attachment_ids| contains duplicates.
-bool ContainsDuplicateAttachments(
-    const syncer::AttachmentIdList& attachment_ids) {
-  syncer::AttachmentIdSet id_set;
+bool ContainsDuplicateAttachments(const AttachmentIdList& attachment_ids) {
+  AttachmentIdSet id_set;
   id_set.insert(attachment_ids.begin(), attachment_ids.end());
   return id_set.size() != attachment_ids.size();
 }
 
 }  // namespace
 
-namespace syncer {
-
 void SyncData::ImmutableSyncEntityTraits::InitializeWrapper(Wrapper* wrapper) {
   *wrapper = new sync_pb::SyncEntity();
 }
 
 void SyncData::ImmutableSyncEntityTraits::DestroyWrapper(Wrapper* wrapper) {
   delete *wrapper;
 }
 
 const sync_pb::SyncEntity& SyncData::ImmutableSyncEntityTraits::Unwrap(
     const Wrapper& wrapper) {
   return *wrapper;
 }
 
 sync_pb::SyncEntity* SyncData::ImmutableSyncEntityTraits::UnwrapMutable(
     Wrapper* wrapper) {
   return *wrapper;
 }
 
 void SyncData::ImmutableSyncEntityTraits::Swap(sync_pb::SyncEntity* t1,
                                                sync_pb::SyncEntity* t2) {
   t1->Swap(t2);
 }
 
 SyncData::SyncData() : id_(kInvalidId), is_valid_(false) {}
 
 SyncData::SyncData(int64_t id,
                    sync_pb::SyncEntity* entity,
                    const base::Time& remote_modification_time,
-                   const syncer::AttachmentServiceProxy& attachment_service)
+                   const AttachmentServiceProxy& attachment_service)
     : id_(id),
       remote_modification_time_(remote_modification_time),
       immutable_entity_(entity),
       attachment_service_(attachment_service),
       is_valid_(true) {}
 
 SyncData::SyncData(const SyncData& other) = default;
 
 SyncData::~SyncData() {}
 
 // Static.
 SyncData SyncData::CreateLocalDelete(const std::string& sync_tag,
                                      ModelType datatype) {
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(datatype, &specifics);
   return CreateLocalData(sync_tag, std::string(), specifics);
 }
 
 // Static.
 SyncData SyncData::CreateLocalData(const std::string& sync_tag,
                                    const std::string& non_unique_title,
                                    const sync_pb::EntitySpecifics& specifics) {
-  syncer::AttachmentIdList attachment_ids;
+  AttachmentIdList attachment_ids;
   return CreateLocalDataWithAttachments(sync_tag, non_unique_title, specifics,
                                         attachment_ids);
 }
 
 // Static.
 SyncData SyncData::CreateLocalDataWithAttachments(
     const std::string& sync_tag,
     const std::string& non_unique_title,
     const sync_pb::EntitySpecifics& specifics,
     const AttachmentIdList& attachment_ids) {
@@ skipping 109 matching lines @@
 }
 
 const std::string& SyncDataRemote::GetClientTagHash() const {
   // It seems that client_defined_unique_tag has a bit of an overloaded use,
   // holding onto the un-hashed tag while local, and then the hashed value when
   // communicating with the server. This usage is copying the latter of these
   // cases, where this is the hashed tag value. The original tag is not sent to
   // the server so we wouldn't be able to set this value anyways. The only way
   // to recreate an un-hashed tag is for the service to do so with a specifics.
   // Should only be used by sessions, see crbug.com/604657.
-  DCHECK_EQ(syncer::SESSIONS, GetDataType());
+  DCHECK_EQ(SESSIONS, GetDataType());
   return immutable_entity_.Get().client_defined_unique_tag();
 }
 
 void SyncDataRemote::GetOrDownloadAttachments(
     const AttachmentIdList& attachment_ids,
     const AttachmentService::GetOrDownloadCallback& callback) {
   attachment_service_.GetOrDownloadAttachments(attachment_ids, callback);
 }
 
 }  // namespace syncer