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

components/sync/engine_impl/model_type_worker.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_ENGINE_IMPL_MODEL_TYPE_WORKER_H_
 #define COMPONENTS_SYNC_ENGINE_IMPL_MODEL_TYPE_WORKER_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 10 matching lines @@
 #include "components/sync/engine_impl/commit_contributor.h"
 #include "components/sync/engine_impl/nudge_handler.h"
 #include "components/sync/engine_impl/update_handler.h"
 #include "components/sync/protocol/data_type_state.pb.h"
 #include "components/sync/protocol/sync.pb.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
-namespace syncer_v2 {
+namespace syncer {
 
 class ModelTypeProcessor;
 class WorkerEntityTracker;
 
 // A smart cache for sync types that use message passing (rather than
 // transactions and the syncable::Directory) to communicate with the sync
 // thread.
 //
 // When the non-blocking sync type wants to talk with the sync server, it will
 // send a message from its thread to this object on the sync thread. This
 // object ensures the appropriate sync server communication gets scheduled and
 // executed. The response, if any, will be returned to the non-blocking sync
 // type's thread eventually.
 //
 // This object also has a role to play in communications in the opposite
 // direction. Sometimes the sync thread will receive changes from the sync
 // server and deliver them here. This object will post this information back to
 // the appropriate component on the model type's thread.
 //
 // This object does more than just pass along messages. It understands the sync
 // protocol, and it can make decisions when it sees conflicting messages. For
 // example, if the sync server sends down an update for a sync entity that is
 // currently pending for commit, this object will detect this condition and
 // cancel the pending commit.
-class ModelTypeWorker : public syncer::UpdateHandler,
-                        public syncer::CommitContributor,
+class ModelTypeWorker : public UpdateHandler,
+                        public CommitContributor,
                         public CommitQueue {
  public:
-  ModelTypeWorker(syncer::ModelType type,
+  ModelTypeWorker(ModelType type,
                   const sync_pb::DataTypeState& initial_state,
-                  std::unique_ptr<syncer::Cryptographer> cryptographer,
-                  syncer::NudgeHandler* nudge_handler,
+                  std::unique_ptr<Cryptographer> cryptographer,
+                  NudgeHandler* nudge_handler,
                   std::unique_ptr<ModelTypeProcessor> model_type_processor);
   ~ModelTypeWorker() override;
 
-  syncer::ModelType GetModelType() const;
+  ModelType GetModelType() const;
 
-  void UpdateCryptographer(
-      std::unique_ptr<syncer::Cryptographer> cryptographer);
+  void UpdateCryptographer(std::unique_ptr<Cryptographer> cryptographer);
 
   // UpdateHandler implementation.
   bool IsInitialSyncEnded() const override;
   void GetDownloadProgress(
       sync_pb::DataTypeProgressMarker* progress_marker) const override;
   void GetDataTypeContext(sync_pb::DataTypeContext* context) const override;
-  syncer::SyncerError ProcessGetUpdatesResponse(
+  SyncerError ProcessGetUpdatesResponse(
       const sync_pb::DataTypeProgressMarker& progress_marker,
       const sync_pb::DataTypeContext& mutated_context,
       const SyncEntityList& applicable_updates,
-      syncer::StatusController* status) override;
-  void ApplyUpdates(syncer::StatusController* status) override;
-  void PassiveApplyUpdates(syncer::StatusController* status) override;
+      StatusController* status) override;
+  void ApplyUpdates(StatusController* status) override;
+  void PassiveApplyUpdates(StatusController* status) override;
 
   // CommitQueue implementation.
   void EnqueueForCommit(const CommitRequestDataList& request_list) override;
 
   // CommitContributor implementation.
-  std::unique_ptr<syncer::CommitContribution> GetContribution(
+  std::unique_ptr<CommitContribution> GetContribution(
       size_t max_entries) override;
 
   // Callback for when our contribution gets a response.
   void OnCommitResponse(CommitResponseDataList* response_list);
 
   base::WeakPtr<ModelTypeWorker> AsWeakPtr();
 
  private:
   using EntityMap = std::map<std::string, std::unique_ptr<WorkerEntityTracker>>;
 
@@ skipping 36 matching lines @@
   // Returns the entity tracker for the given |tag_hash|, or nullptr.
   WorkerEntityTracker* GetEntityTracker(const std::string& tag_hash);
 
   // Creates an entity tracker in the map using the given |data| and returns a
   // pointer to it. Requires that one doesn't exist for data.client_tag_hash.
   WorkerEntityTracker* CreateEntityTracker(const EntityData& data);
 
   // Gets the entity tracker for |data| or creates one if it doesn't exist.
   WorkerEntityTracker* GetOrCreateEntityTracker(const EntityData& data);
 
-  syncer::ModelType type_;
+  ModelType type_;
 
   // State that applies to the entire model type.
   sync_pb::DataTypeState data_type_state_;
 
   // Pointer to the ModelTypeProcessor associated with this worker. Never null.
   std::unique_ptr<ModelTypeProcessor> model_type_processor_;
 
   // A private copy of the most recent cryptographer known to sync.
   // Initialized at construction time and updated with UpdateCryptographer().
   // NULL if encryption is not enabled for this type.
-  std::unique_ptr<syncer::Cryptographer> cryptographer_;
+  std::unique_ptr<Cryptographer> cryptographer_;
 
   // Interface used to access and send nudges to the sync scheduler. Not owned.
-  syncer::NudgeHandler* nudge_handler_;
+  NudgeHandler* nudge_handler_;
 
   // A map of per-entity information, keyed by client_tag_hash.
   //
   // When commits are pending, their information is stored here. This
   // information is dropped from memory when the commit succeeds or gets
   // cancelled.
   //
   // This also stores some information related to received server state in
   // order to implement reflection blocking and conflict detection. This
   // information is kept in memory indefinitely.
   EntityMap entities_;
 
   // Accumulates all the updates from a single GetUpdates cycle in memory so
   // they can all be sent to the processor at once.
   UpdateResponseDataList pending_updates_;
 
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<ModelTypeWorker> weak_ptr_factory_;
 };
 
-}  // namespace syncer_v2
+}  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_ENGINE_IMPL_MODEL_TYPE_WORKER_H_