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

components/sync/engine_impl/get_updates_processor.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/engine_impl/get_updates_processor.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <utility>
 
 #include "base/trace_event/trace_event.h"
 #include "components/sync/engine/events/get_updates_response_event.h"
 #include "components/sync/engine_impl/cycle/status_controller.h"
 #include "components/sync/engine_impl/cycle/sync_cycle.h"
 #include "components/sync/engine_impl/get_updates_delegate.h"
 #include "components/sync/engine_impl/syncer_proto_util.h"
 #include "components/sync/engine_impl/update_handler.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/nigori_handler.h"
 #include "components/sync/syncable/syncable_read_transaction.h"
 
-typedef std::vector<const sync_pb::SyncEntity*> SyncEntityList;
-typedef std::map<syncer::ModelType, SyncEntityList> TypeSyncEntityMap;
-
 namespace syncer {
 
+namespace {
+
+typedef std::vector<const sync_pb::SyncEntity*> SyncEntityList;
+typedef std::map<ModelType, SyncEntityList> TypeSyncEntityMap;
 typedef std::map<ModelType, size_t> TypeToIndexMap;
 
-namespace {
-
 bool ShouldRequestEncryptionKey(SyncCycleContext* context) {
   syncable::Directory* dir = context->directory();
   syncable::ReadTransaction trans(FROM_HERE, dir);
   syncable::NigoriHandler* nigori_handler = dir->GetNigoriHandler();
   return nigori_handler->NeedKeystoreKey(&trans);
 }
 
 SyncerError HandleGetEncryptionKeyResponse(
     const sync_pb::ClientToServerResponse& update_response,
     syncable::Directory* dir) {
@@ skipping 238 matching lines @@
     ModelTypeSet request_types,
     StatusController* status) {
   status->increment_num_updates_downloaded_by(gu_response.entries_size());
 
   // The changes remaining field is used to prevent the client from looping.  If
   // that field is being set incorrectly, we're in big trouble.
   if (!gu_response.has_changes_remaining()) {
     return SERVER_RESPONSE_VALIDATION_FAILED;
   }
 
-  syncer::SyncerError result =
+  SyncerError result =
       ProcessGetUpdatesResponse(request_types, gu_response, status);
-  if (result != syncer::SYNCER_OK)
+  if (result != SYNCER_OK)
     return result;
 
   if (gu_response.changes_remaining() == 0) {
     return SYNCER_OK;
   } else {
     return SERVER_MORE_TO_DOWNLOAD;
   }
 }
 
-syncer::SyncerError GetUpdatesProcessor::ProcessGetUpdatesResponse(
+SyncerError GetUpdatesProcessor::ProcessGetUpdatesResponse(
     ModelTypeSet gu_types,
     const sync_pb::GetUpdatesResponse& gu_response,
     StatusController* status_controller) {
   TypeSyncEntityMap updates_by_type;
   PartitionUpdatesByType(gu_response, gu_types, &updates_by_type);
   DCHECK_EQ(gu_types.Size(), updates_by_type.size());
 
   TypeToIndexMap progress_index_by_type;
   PartitionProgressMarkersByType(gu_response, gu_types,
                                  &progress_index_by_type);
   if (gu_types.Size() != progress_index_by_type.size()) {
     NOTREACHED() << "Missing progress markers in GetUpdates response.";
-    return syncer::SERVER_RESPONSE_VALIDATION_FAILED;
+    return SERVER_RESPONSE_VALIDATION_FAILED;
   }
 
   TypeToIndexMap context_by_type;
   PartitionContextMutationsByType(gu_response, gu_types, &context_by_type);
 
   // Iterate over these maps in parallel, processing updates for each type.
   TypeToIndexMap::iterator progress_marker_iter =
       progress_index_by_type.begin();
   TypeSyncEntityMap::iterator updates_iter = updates_by_type.begin();
   for (; (progress_marker_iter != progress_index_by_type.end() &&
           updates_iter != updates_by_type.end());
        ++progress_marker_iter, ++updates_iter) {
     DCHECK_EQ(progress_marker_iter->first, updates_iter->first);
     ModelType type = progress_marker_iter->first;
 
     UpdateHandlerMap::iterator update_handler_iter =
         update_handler_map_->find(type);
 
     sync_pb::DataTypeContext context;
     TypeToIndexMap::iterator context_iter = context_by_type.find(type);
     if (context_iter != context_by_type.end())
       context.CopyFrom(gu_response.context_mutations(context_iter->second));
 
     if (update_handler_iter != update_handler_map_->end()) {
-      syncer::SyncerError result =
+      SyncerError result =
           update_handler_iter->second->ProcessGetUpdatesResponse(
               gu_response.new_progress_marker(progress_marker_iter->second),
               context, updates_iter->second, status_controller);
-      if (result != syncer::SYNCER_OK)
+      if (result != SYNCER_OK)
         return result;
     } else {
       DLOG(WARNING) << "Ignoring received updates of a type we can't handle.  "
                     << "Type is: " << ModelTypeToString(type);
       continue;
     }
   }
   DCHECK(progress_marker_iter == progress_index_by_type.end() &&
          updates_iter == updates_by_type.end());
 
-  return syncer::SYNCER_OK;
+  return SYNCER_OK;
 }
 
 void GetUpdatesProcessor::ApplyUpdates(ModelTypeSet gu_types,
                                        StatusController* status_controller) {
   status_controller->set_get_updates_request_types(gu_types);
   delegate_.ApplyUpdates(gu_types, status_controller, update_handler_map_);
 }
 
 void GetUpdatesProcessor::CopyClientDebugInfo(
     DebugInfoGetter* debug_info_getter,
     sync_pb::DebugInfo* debug_info) {
   DVLOG(1) << "Copying client debug info to send.";
   debug_info_getter->GetDebugInfo(debug_info);
 }
 
 }  // namespace syncer