[Sync] Put everything in sync/api into csync namespace

chrome/browser/sync/glue/data_type_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_DATA_TYPE_CONTROLLER_H__
 #define CHROME_BROWSER_SYNC_GLUE_DATA_TYPE_CONTROLLER_H__
 #pragma once
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "chrome/browser/sync/glue/data_type_error_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 
+namespace csync {
 class SyncError;
+}
 
 namespace browser_sync {
 
 // Data type controllers need to be refcounted threadsafe, as they may
 // need to run model associator or change processor on other threads.
 class DataTypeController
     : public base::RefCountedThreadSafe<
           DataTypeController, content::BrowserThread::DeleteOnUIThread>,
       public DataTypeErrorHandler {
  public:
@@ skipping 22 matching lines @@
     BUSY,                 // Start() was called while already in progress.
     NOT_ENABLED,          // This data type is not enabled for the current user.
     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.
     MAX_START_RESULT
   };
 
-  typedef base::Callback<void(StartResult, const SyncError&)> StartCallback;
+  typedef base::Callback<void(StartResult,
+                              const csync::SyncError&)> StartCallback;
 
   typedef base::Callback<void(syncable::ModelType,
-                              SyncError)> ModelLoadCallback;
+                              csync::SyncError)> ModelLoadCallback;
 
   typedef std::map<syncable::ModelType,
                    scoped_refptr<DataTypeController> > TypeMap;
   typedef std::map<syncable::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(StartResult result);
 
   // Begins asynchronous operation of loading the model to get it ready for
@@ skipping 22 matching lines @@
   // The model safe group of this data type.  This should reflect the
   // thread that should be used to modify the data type's native
   // model.
   virtual csync::ModelSafeGroup model_safe_group() const = 0;
 
   // Current state of the data type controller.
   virtual State state() const = 0;
 
   // Partial implementation of DataTypeErrorHandler.
   // This is thread safe.
-  virtual SyncError CreateAndUploadError(
+  virtual csync::SyncError CreateAndUploadError(
       const tracked_objects::Location& location,
       const std::string& message,
       syncable::ModelType type) OVERRIDE;
 
  protected:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<DataTypeController>;
 
   // If the DTC is waiting for models to load, once the models are
   // loaded the datatype service will call this function on DTC to let
   // us know that it is safe to start associating.
   virtual void OnModelLoaded() = 0;
 
   virtual ~DataTypeController() {}
 
   // Handles the reporting of unrecoverable error. It records stuff in
   // UMA and reports to breakpad.
   // Virtual for testing purpose.
   virtual void RecordUnrecoverableError(
       const tracked_objects::Location& from_here,
       const std::string& message);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_DATA_TYPE_CONTROLLER_H__