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

chrome/browser/sync/glue/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/frontend_data_type_controller.h"
 
 #include "base/logging.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
@@ skipping 22 matching lines @@
   DCHECK(profile);
   DCHECK(sync_service);
 }
 
 void FrontendDataTypeController::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;
   }
 
   DCHECK(model_load_callback_.is_null());
 
   model_load_callback_ = model_load_callback;
   state_ = MODEL_STARTING;
   if (!StartModels()) {
     // If we are waiting for some external service to load before associating
     // or we failed to start the models, we exit early. state_ will control
     // what we perform next.
     DCHECK(state_ == NOT_RUNNING || state_ == MODEL_STARTING);
     return;
   }
 
   OnModelLoaded();
 }
 
 void FrontendDataTypeController::OnModelLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!model_load_callback_.is_null());
   DCHECK_EQ(state_, MODEL_STARTING);
 
   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 FrontendDataTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!start_callback.is_null());
   DCHECK(start_callback_.is_null());
   DCHECK_EQ(state_, MODEL_LOADED);
 
   start_callback_ = start_callback;
@@ skipping 20 matching lines @@
     // still in MODEL_STARTING.
     return;
   }
   DCHECK(start_callback_.is_null());
 
   CleanUpState();
 
   sync_service_->DeactivateDataType(type());
 
   if (model_associator()) {
-    SyncError error;  // Not used.
+    csync::SyncError error;  // Not used.
     error = model_associator()->DisassociateModels();
   }
 
   set_model_associator(NULL);
   change_processor_.reset();
 
   state_ = NOT_RUNNING;
 }
 
 csync::ModelSafeGroup FrontendDataTypeController::model_safe_group()
@@ skipping 31 matching lines @@
   DCHECK_EQ(state_, MODEL_STARTING);
   // By default, no additional services need to be started before we can proceed
   // with model association.
   return true;
 }
 
 bool FrontendDataTypeController::Associate() {
   DCHECK_EQ(state_, ASSOCIATING);
   CreateSyncComponents();
   if (!model_associator()->CryptoReadyIfNecessary()) {
-    StartFailed(NEEDS_CRYPTO, SyncError());
+    StartFailed(NEEDS_CRYPTO, csync::SyncError());
     return false;
   }
 
   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 false;
   }
 
   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 false;
   }
 
   sync_service_->ActivateDataType(type(), model_safe_group(),
                                   change_processor());
@@ skipping 14 matching lines @@
   // Do nothing by default.
 }
 
 void FrontendDataTypeController::CleanUp() {
   CleanUpState();
   set_model_associator(NULL);
   change_processor_.reset();
 }
 
 void FrontendDataTypeController::StartFailed(StartResult result,
-                                             const SyncError& error) {
+                                             const csync::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsUnrecoverableResult(result))
     RecordUnrecoverableError(FROM_HERE, "StartFailed");
 
   CleanUp();
   if (result == ASSOCIATION_FAILED) {
     state_ = DISABLED;
   } else {
     state_ = NOT_RUNNING;
   }
   RecordStartFailure(result);
 
   // We have to release the callback before we call it, since it's possible
   // invoking the callback will trigger a call to STOP(), which will get
   // confused by the non-NULL start_callback_.
   StartCallback callback = start_callback_;
   start_callback_.Reset();
   callback.Run(result, error);
 }
 
 void FrontendDataTypeController::AbortModelLoad() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CleanUp();
   state_ = NOT_RUNNING;
   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()));
 }
 
 void FrontendDataTypeController::FinishStart(StartResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // We have to release the callback before we call it, since it's possible
   // invoking the callback will trigger a call to STOP(), which will get
   // confused by the non-NULL start_callback_.
   StartCallback callback = start_callback_;
   start_callback_.Reset();
-  callback.Run(result, SyncError());
+  callback.Run(result, csync::SyncError());
 }
 
 void FrontendDataTypeController::RecordAssociationTime(base::TimeDelta time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #define PER_DATA_TYPE_MACRO(type_str) \
     UMA_HISTOGRAM_TIMES("Sync." type_str "AssociationTime", time);
   SYNC_DATA_TYPE_HISTOGRAM(type());
 #undef PER_DATA_TYPE_MACRO
 }
 
@@ skipping 20 matching lines @@
 ChangeProcessor* FrontendDataTypeController::change_processor() const {
   return change_processor_.get();
 }
 
 void FrontendDataTypeController::set_change_processor(
     ChangeProcessor* change_processor) {
   change_processor_.reset(change_processor);
 }
 
 }  // namespace browser_sync