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

chrome/browser/sync/glue/new_non_frontend_data_type_controller.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 "chrome/browser/sync/glue/new_non_frontend_data_type_controller.h"
 
 #include "base/logging.h"
 #include "chrome/browser/sync/glue/shared_change_processor_ref.h"
 #include "chrome/browser/sync/profile_sync_components_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
@@ skipping 12 matching lines @@
     ProfileSyncService* sync_service)
     : NonFrontendDataTypeController(profile_sync_factory,
                                     profile,
                                     sync_service) {}
 
 void NewNonFrontendDataTypeController::LoadModels(
     const ModelLoadCallback& model_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!model_load_callback.is_null());
   if (state() != NOT_RUNNING) {
-    model_load_callback.Run(type(), SyncError(FROM_HERE,
+    model_load_callback.Run(type(), csync::SyncError(FROM_HERE,
                                               "Model already running",
                                               type()));
     return;
   }
 
   set_state(MODEL_STARTING);
 
   // Since we can't be called multiple times before Stop() is called,
   // |shared_change_processor_| must be NULL here.
   DCHECK(!shared_change_processor_.get());
@@ skipping 12 matching lines @@
   OnModelLoaded();
 }
 
 void NewNonFrontendDataTypeController::OnModelLoaded() {
   DCHECK_EQ(state_, MODEL_STARTING);
   DCHECK(!model_load_callback_.is_null());
   set_state(MODEL_LOADED);
 
   ModelLoadCallback model_load_callback = model_load_callback_;
   model_load_callback_.Reset();
-  model_load_callback.Run(type(), SyncError());
+  model_load_callback.Run(type(), csync::SyncError());
 }
 
 void NewNonFrontendDataTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!start_callback.is_null());
   DCHECK_EQ(state_, MODEL_LOADED);
   set_state(ASSOCIATING);
 
   set_start_callback(start_callback);
   if (!StartAssociationAsync()) {
-    SyncError error(FROM_HERE, "Failed to post StartAssociation", type());
+    csync::SyncError error(
+        FROM_HERE, "Failed to post StartAssociation", type());
     StartDoneImpl(ASSOCIATION_FAILED, NOT_RUNNING, error);
     // StartDoneImpl should have called ClearSharedChangeProcessor();
     DCHECK(!shared_change_processor_.get());
     return;
   }
 }
 
 void NewNonFrontendDataTypeController::Stop() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state() == NOT_RUNNING) {
     // Stop() should never be called for datatypes that are already stopped.
     NOTREACHED();
     return;
   }
 
   // Disconnect the change processor. At this point, the
-  // SyncableService can no longer interact with the Syncer, even if
+  // csync::SyncableService can no longer interact with the Syncer, even if
   // it hasn't finished MergeDataAndStartSyncing.
   ClearSharedChangeProcessor();
 
   // If we haven't finished starting, we need to abort the start.
   switch (state()) {
     case MODEL_STARTING:
       set_state(STOPPING);
       AbortModelStarting();
       return;  // The datatype was never activated, we're done.
     case ASSOCIATING:
       set_state(STOPPING);
-      StartDoneImpl(ABORTED, NOT_RUNNING, SyncError());
+      StartDoneImpl(ABORTED, NOT_RUNNING, csync::SyncError());
       // We continue on to deactivate the datatype and stop the local service.
       break;
     case DISABLED:
       // If we're disabled we never succeded associating and never activated the
       // datatype. We would have already stopped the local service in
       // StartDoneImpl(..).
       set_state(NOT_RUNNING);
       StopModels();
       return;
     default:
@@ skipping 16 matching lines @@
   set_state(NOT_RUNNING);
 }
 
 NewNonFrontendDataTypeController::NewNonFrontendDataTypeController() {}
 
 NewNonFrontendDataTypeController::~NewNonFrontendDataTypeController() {}
 
 void NewNonFrontendDataTypeController::StartDone(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
-    const SyncError& error) {
+    const csync::SyncError& error) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NewNonFrontendDataTypeController::StartDoneImpl,
           this,
           result,
           new_state,
           error));
 }
 
 void NewNonFrontendDataTypeController::StartDoneImpl(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
-    const SyncError& error) {
+    const csync::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // If we failed to start up, and we haven't been stopped yet, we need to
   // ensure we clean up the local service and shared change processor properly.
   if (new_state != RUNNING && state() != NOT_RUNNING && state() != STOPPING) {
     ClearSharedChangeProcessor();
     StopLocalServiceAsync();
   }
   NonFrontendDataTypeController::StartDoneImpl(result, new_state, error);
 }
 
 void NewNonFrontendDataTypeController::AbortModelStarting() {
   set_state(NOT_RUNNING);
   StopModels();
   ModelLoadCallback model_load_callback = model_load_callback_;
   model_load_callback_.Reset();
-  model_load_callback.Run(type(), SyncError(FROM_HERE,
+  model_load_callback.Run(type(), csync::SyncError(FROM_HERE,
                                             "ABORTED",
                                             type()));
 }
 
 bool NewNonFrontendDataTypeController::StartAssociationAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(state(), ASSOCIATING);
   return PostTaskOnBackendThread(
       FROM_HERE,
       base::Bind(
           &NewNonFrontendDataTypeController::
               StartAssociationWithSharedChangeProcessor,
           this,
           shared_change_processor_));
 }
 
 // This method can execute after we've already stopped (and possibly even
 // destroyed) both the Syncer and the SyncableService. As a result, all actions
 // must either have no side effects outside of the DTC or must be protected
 // by |shared_change_processor|, which is guaranteed to have been Disconnected
 // if the syncer shut down.
 void NewNonFrontendDataTypeController::
     StartAssociationWithSharedChangeProcessor(
         const scoped_refptr<SharedChangeProcessor>& shared_change_processor) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(shared_change_processor.get());
 
   // Connect |shared_change_processor| to the syncer and get the
-  // SyncableService associated with type().
+  // csync::SyncableService associated with type().
   // Note that it's possible the shared_change_processor has already been
   // disconnected at this point, so all our accesses to the syncer from this
   // point on are through it.
   local_service_ = shared_change_processor->Connect(profile_sync_factory(),
                                                     profile_sync_service(),
                                                     this,
                                                     type());
   if (!local_service_.get()) {
-    SyncError error(FROM_HERE, "Failed to connect to syncer.", type());
+    csync::SyncError error(FROM_HERE, "Failed to connect to syncer.", type());
     StartFailed(UNRECOVERABLE_ERROR, error);
     return;
   }
 
   if (!shared_change_processor->CryptoReadyIfNecessary()) {
-    StartFailed(NEEDS_CRYPTO, SyncError());
+    StartFailed(NEEDS_CRYPTO, csync::SyncError());
     return;
   }
 
   bool sync_has_nodes = false;
   if (!shared_change_processor->SyncModelHasUserCreatedNodes(&sync_has_nodes)) {
-    SyncError error(FROM_HERE, "Failed to load sync nodes", type());
+    csync::SyncError error(FROM_HERE, "Failed to load sync nodes", type());
     StartFailed(UNRECOVERABLE_ERROR, error);
     return;
   }
 
   base::TimeTicks start_time = base::TimeTicks::Now();
-  SyncError error;
-  SyncDataList initial_sync_data;
+  csync::SyncError error;
+  csync::SyncDataList initial_sync_data;
   error = shared_change_processor->GetSyncData(&initial_sync_data);
   if (error.IsSet()) {
     StartFailed(ASSOCIATION_FAILED, error);
     return;
   }
   // Passes a reference to |shared_change_processor|.
   error = local_service_->MergeDataAndStartSyncing(
       type(),
       initial_sync_data,
-      scoped_ptr<SyncChangeProcessor>(
+      scoped_ptr<csync::SyncChangeProcessor>(
           new SharedChangeProcessorRef(shared_change_processor)),
-      scoped_ptr<SyncErrorFactory>(
+      scoped_ptr<csync::SyncErrorFactory>(
           new SharedChangeProcessorRef(shared_change_processor)));
   RecordAssociationTime(base::TimeTicks::Now() - start_time);
   if (error.IsSet()) {
     StartFailed(ASSOCIATION_FAILED, error);
     return;
   }
 
   // If we've been disconnected, profile_sync_service() may return an invalid
   // pointer, but |shared_change_processor| protects us from attempting to
   // access it.
   // Note: This must be done on the datatype's thread to ensure local_service_
   // doesn't start trying to push changes from its thread before we activate
   // the datatype.
   shared_change_processor->ActivateDataType(model_safe_group());
-  StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK, RUNNING, SyncError());
+  StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK, RUNNING, csync::SyncError());
 }
 
 void NewNonFrontendDataTypeController::ClearSharedChangeProcessor() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // |shared_change_processor_| can already be NULL if Stop() is
   // called after StartDoneImpl(_, DISABLED, _).
   if (shared_change_processor_.get()) {
     shared_change_processor_->Disconnect();
     shared_change_processor_ = NULL;
   }
@@ skipping 11 matching lines @@
   if (local_service_.get())
     local_service_->StopSyncing(type());
   local_service_.reset();
 }
 
 void NewNonFrontendDataTypeController::CreateSyncComponents() {
   NOTIMPLEMENTED();
 }
 
 }  // namepsace browser_sync