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

components/sync/driver/data_type_controller.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_DRIVER_DATA_TYPE_CONTROLLER_H__
 #define COMPONENTS_SYNC_DRIVER_DATA_TYPE_CONTROLLER_H__
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "components/sync/api/data_type_error_handler.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
 
 namespace syncer {
+
+class BackendDataTypeConfigurer;
 class SyncError;
 class SyncMergeResult;
-}
-
-namespace sync_driver {
-class BackendDataTypeConfigurer;
 
 // DataTypeControllers are responsible for managing the state of a single data
 // type. They are not thread safe and should only be used on the UI thread.
 class DataTypeController : public base::SupportsWeakPtr<DataTypeController> {
  public:
   enum State {
     NOT_RUNNING,     // The controller has never been started or has previously
                      // been stopped.  Must be in this state to start.
     MODEL_STARTING,  // The controller is waiting on dependent services
                      // that need to be available before model
@@ skipping 18 matching lines @@
                           // determined by cloud state.
     ASSOCIATION_FAILED,   // An error occurred during model association.
     ABORTED,              // Start was aborted by calling Stop().
     UNRECOVERABLE_ERROR,  // An unrecoverable error occured.
     NEEDS_CRYPTO,         // The data type cannot be started yet because it
                           // depends on the cryptographer.
     RUNTIME_ERROR,        // After starting, a runtime error was encountered.
     MAX_CONFIGURE_RESULT
   };
 
-  typedef base::Callback<void(ConfigureResult,
-                              const syncer::SyncMergeResult&,
-                              const syncer::SyncMergeResult&)>
+  typedef base::Callback<
+      void(ConfigureResult, const SyncMergeResult&, const SyncMergeResult&)>
       StartCallback;
 
-  typedef base::Callback<void(syncer::ModelType, const syncer::SyncError&)>
-      ModelLoadCallback;
+  typedef base::Callback<void(ModelType, const SyncError&)> ModelLoadCallback;
 
-  typedef base::Callback<void(const syncer::ModelType,
+  typedef base::Callback<void(const ModelType,
                               std::unique_ptr<base::ListValue>)>
       AllNodesCallback;
 
-  typedef std::map<syncer::ModelType, std::unique_ptr<DataTypeController>>
-      TypeMap;
-  typedef std::map<syncer::ModelType, DataTypeController::State> StateMap;
+  typedef std::map<ModelType, std::unique_ptr<DataTypeController>> TypeMap;
+  typedef std::map<ModelType, DataTypeController::State> StateMap;
 
   // Returns true if the start result should trigger an unrecoverable error.
   // Public so unit tests can use this function as well.
   static bool IsUnrecoverableResult(ConfigureResult result);
 
   // Returns true if the datatype started successfully.
   static bool IsSuccessfulResult(ConfigureResult result);
 
   virtual ~DataTypeController();
 
@@ skipping 40 matching lines @@
   // propagate from sync again from point where Stop() is called.
   virtual void Stop() = 0;
 
   // Name of this data type.  For logging purposes only.
   virtual std::string name() const = 0;
 
   // Current state of the data type controller.
   virtual State state() const = 0;
 
   // Unique model type for this data type controller.
-  syncer::ModelType type() const { return type_; }
+  ModelType type() const { return type_; }
 
   // Whether the DataTypeController is ready to start. This is useful if the
   // datatype itself must make the decision about whether it should be enabled
   // at all (and therefore whether the initial download of the sync data for
   // the type should be performed).
   // Returns true by default.
   virtual bool ReadyForStart() const;
 
   // Returns a ListValue representing all nodes for this data type through
   // |callback| on this thread.
   // Used for populating nodes in Sync Node Browser of chrome://sync-internals.
   virtual void GetAllNodes(const AllNodesCallback& callback) = 0;
 
  protected:
-  DataTypeController(syncer::ModelType type, const base::Closure& dump_stack);
+  DataTypeController(ModelType type, const base::Closure& dump_stack);
 
   // Create an error handler that reports back to this controller.
-  virtual std::unique_ptr<syncer::DataTypeErrorHandler>
-  CreateErrorHandler() = 0;
+  virtual std::unique_ptr<DataTypeErrorHandler> CreateErrorHandler() = 0;
 
   // Allows subclasses to DCHECK that they're on the correct thread.
   bool CalledOnValidThread() const;
 
   // Callback to dump and upload a stack trace when an error occurs.
   base::Closure dump_stack_;
 
  private:
   // The type this object is responsible for controlling.
-  const syncer::ModelType type_;
+  const ModelType type_;
 
   // Used to check that functions are called on the correct thread.
   base::ThreadChecker thread_checker_;
 };
 
-}  // namespace sync_driver
+}  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_DATA_TYPE_CONTROLLER_H__