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

chrome/browser/sync/glue/ui_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/ui_data_type_controller.h"
 
 #include "base/logging.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/shared_change_processor_ref.h"
 #include "chrome/browser/sync/profile_sync_components_factory.h"
@@ skipping 36 matching lines @@
 UIDataTypeController::~UIDataTypeController() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void UIDataTypeController::LoadModels(
     const ModelLoadCallback& model_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!model_load_callback.is_null());
   DCHECK(syncable::IsRealDataType(type_));
   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;
   }
 
   // Since we can't be called multiple times before Stop() is called,
   // |shared_change_processor_| must be NULL here.
   DCHECK(!shared_change_processor_.get());
   shared_change_processor_ =
       profile_sync_factory_->CreateSharedChangeProcessor();
   DCHECK(shared_change_processor_.get());
 
   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;
   }
 
   state_ = MODEL_LOADED;
   model_load_callback_.Reset();
-  model_load_callback.Run(type(), SyncError());
+  model_load_callback.Run(type(), csync::SyncError());
 }
 
 void UIDataTypeController::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 UIDataTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!start_callback.is_null());
   DCHECK_EQ(state_, MODEL_LOADED);
 
   start_callback_ = start_callback;
   state_ = ASSOCIATING;
   Associate();
   // It's possible StartDone(..) resulted in a Stop() call, or that association
   // failed, so we just verify that the state has moved foward.
   DCHECK_NE(state_, ASSOCIATING);
 }
 
 bool UIDataTypeController::StartModels() {
   DCHECK_EQ(state_, MODEL_STARTING);
   // By default, no additional services need to be started before we can proceed
   // with model association.
   return true;
 }
 
 void UIDataTypeController::Associate() {
   DCHECK_EQ(state_, ASSOCIATING);
 
   // Connect |shared_change_processor_| to the syncer and get the
-  // SyncableService associated with type().
+  // csync::SyncableService associated with type().
   local_service_ = shared_change_processor_->Connect(profile_sync_factory_,
                                                      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;
   }
 
   shared_change_processor_->ActivateDataType(model_safe_group());
   state_ = RUNNING;
   StartDone(sync_has_nodes ? OK : OK_FIRST_RUN);
 }
 
 void UIDataTypeController::StartFailed(StartResult result,
-                                       const SyncError& error) {
+                                       const csync::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (IsUnrecoverableResult(result))
     RecordUnrecoverableError(FROM_HERE, "StartFailed");
   StopModels();
   if (result == ASSOCIATION_FAILED) {
     state_ = DISABLED;
   } else {
     state_ = NOT_RUNNING;
   }
   RecordStartFailure(result);
@@ skipping 14 matching lines @@
 void UIDataTypeController::AbortModelLoad() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   state_ = NOT_RUNNING;
 
   if (shared_change_processor_.get()) {
     shared_change_processor_ = NULL;
   }
 
   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 UIDataTypeController::StartDone(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 UIDataTypeController::Stop() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(syncable::IsRealDataType(type_));
 
   State prev_state = state_;
   state_ = STOPPING;
 
   if (shared_change_processor_.get()) {
@@ skipping 64 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures", type(),
                             syncable::MODEL_TYPE_COUNT);
 #define PER_DATA_TYPE_MACRO(type_str) \
     UMA_HISTOGRAM_ENUMERATION("Sync." type_str "StartFailure", result, \
                               MAX_START_RESULT);
   SYNC_DATA_TYPE_HISTOGRAM(type());
 #undef PER_DATA_TYPE_MACRO
 }
 
 }  // namespace browser_sync