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

chrome/browser/sync/glue/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/non_frontend_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 30 matching lines @@
   DCHECK(profile_sync_service_);
 }
 
 void NonFrontendDataTypeController::LoadModels(
     const ModelLoadCallback& model_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!model_load_callback.is_null());
   start_association_called_.Reset();
   start_models_failed_ = false;
   if (state_ != NOT_RUNNING) {
-    model_load_callback.Run(type(), SyncError(FROM_HERE,
+    model_load_callback.Run(type(), csync::SyncError(FROM_HERE,
                                               "Model already loaded",
                                               type()));
     return;
   }
 
   state_ = MODEL_STARTING;
   if (!StartModels()) {
     start_models_failed_ = true;
     // We failed to start the models. There is no point in waiting.
     // Note: This code is deprecated. The only 2 datatypes here,
     // passwords and typed urls, dont have any special loading. So if we
     // get a false it means they failed.
     DCHECK(state_ == NOT_RUNNING || state_ == MODEL_STARTING
            || state_ == DISABLED);
-    model_load_callback.Run(type(), SyncError(FROM_HERE,
+    model_load_callback.Run(type(), csync::SyncError(FROM_HERE,
                                               "Failed loading",
                                               type()));
     return;
   }
   state_ = MODEL_LOADED;
 
-  model_load_callback.Run(type(), SyncError());
+  model_load_callback.Run(type(), csync::SyncError());
 }
 
 void NonFrontendDataTypeController::OnModelLoaded() {
   NOTREACHED();
 }
 
 void NonFrontendDataTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!start_callback.is_null());
   DCHECK_EQ(state_, MODEL_LOADED);
 
   // Kick off association on the thread the datatype resides on.
   state_ = ASSOCIATING;
   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, DISABLED, error);
   }
 }
 
 void NonFrontendDataTypeController::StopWhileAssociating() {
   state_ = STOPPING;
   {
     base::AutoLock lock(abort_association_lock_);
     abort_association_ = true;
     if (model_associator_.get())
       model_associator_->AbortAssociation();
     if (!start_association_called_.IsSignaled()) {
-      StartDoneImpl(ABORTED, NOT_RUNNING, SyncError());
+      StartDoneImpl(ABORTED, NOT_RUNNING, csync::SyncError());
       return; // There is nothing more for us to do.
     }
   }
 
   // Wait for the model association to abort.
   if (start_association_called_.IsSignaled()) {
     LOG(INFO) << "Stopping after |StartAssocation| is called.";
     if (start_models_failed_) {
       LOG(INFO) << "Start models failed";
       abort_association_complete_.Wait();
     } else {
       LOG(INFO) << "Start models succeeded";
       abort_association_complete_.Wait();
     }
   } else {
     LOG(INFO) << "Stopping before |StartAssocation| is called.";
     if (start_models_failed_) {
       LOG(INFO) << "Start models failed";
       abort_association_complete_.Wait();
     } else {
       LOG(INFO) << "Start models succeeded";
       abort_association_complete_.Wait();
     }
 
   }
 
-  StartDoneImpl(ABORTED, STOPPING, SyncError());
+  StartDoneImpl(ABORTED, STOPPING, csync::SyncError());
 }
 
 namespace {
 // Helper function that signals the UI thread once the StopAssociation task
 // has finished completing (this task is queued after the StopAssociation task).
 void SignalCallback(base::WaitableEvent* wait_event) {
   wait_event->Signal();
 }
 }  // namespace
 
@@ skipping 136 matching lines @@
 
 bool NonFrontendDataTypeController::StartModels() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(state_, MODEL_STARTING);
   // By default, no additional services need to be started before we can proceed
   // with model association, so do nothing.
   return true;
 }
 
 void NonFrontendDataTypeController::StartFailed(StartResult result,
-                                                const SyncError& error) {
+                                                const csync::SyncError& error) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsUnrecoverableResult(result))
     RecordUnrecoverableError(FROM_HERE, "StartFailed");
   StopAssociation();
   StartDone(result,
             result == ASSOCIATION_FAILED ? DISABLED : NOT_RUNNING,
             error);
 }
 
 void NonFrontendDataTypeController::StartDone(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
-    const SyncError& error) {
+    const csync::SyncError& error) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   abort_association_complete_.Signal();
   base::AutoLock lock(abort_association_lock_);
   if (!abort_association_) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&NonFrontendDataTypeController::StartDoneImpl,
                    this,
                    result,
                    new_state,
                    error));
   }
 }
 
 void NonFrontendDataTypeController::StartDoneImpl(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
-    const SyncError& error) {
+    const csync::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // It's possible to have StartDoneImpl called first from the UI thread
   // (due to Stop being called) and then posted from the non-UI thread. In
   // this case, we drop the second call because we've already been stopped.
   if (state_ == NOT_RUNNING) {
     DCHECK(start_callback_.is_null());
     return;
   }
 
   state_ = new_state;
@@ skipping 103 matching lines @@
       abort_association_complete_.Signal();
       return;
     }
     start_association_called_.Signal();
     CreateSyncComponents();
   }
 
   DCHECK_EQ(state_, ASSOCIATING);
 
   if (!model_associator_->CryptoReadyIfNecessary()) {
-    StartFailed(NEEDS_CRYPTO, SyncError());
+    StartFailed(NEEDS_CRYPTO, csync::SyncError());
     return;
   }
 
   bool sync_has_nodes = false;
   if (!model_associator_->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;
+  csync::SyncError error;
   error = model_associator_->AssociateModels();
   // TODO(lipalani): crbug.com/122690 - handle abort.
   RecordAssociationTime(base::TimeTicks::Now() - start_time);
   if (error.IsSet()) {
     StartFailed(ASSOCIATION_FAILED, error);
     return;
   }
 
   profile_sync_service_->ActivateDataType(type(), model_safe_group(),
                                           change_processor());
-  StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK, RUNNING, SyncError());
+  StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK, RUNNING, csync::SyncError());
 }
 
 bool NonFrontendDataTypeController::StopAssociationAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(state(), STOPPING);
   if (PostTaskOnBackendThread(
           FROM_HERE,
           base::Bind(
               &NonFrontendDataTypeController::StopAssociation, this))) {
     // The remote thread will hold on to a reference to this object until
@@ skipping 12 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 void NonFrontendDataTypeController::StopAssociation() {
   DCHECK(!HasOneRef());
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (model_associator_.get()) {
-    SyncError error;  // Not used.
+    csync::SyncError error;  // Not used.
     error = model_associator_->DisassociateModels();
   }
   model_associator_.reset();
   change_processor_.reset();
 }
 
 }  // namespace browser_sync