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

chrome/browser/sync/glue/data_type_manager_impl.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/data_type_manager_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 179 matching lines @@
     model_association_manager_.ResetForReconfiguration();
     ProcessReconfigure();
     return;
   }
 
   if (!failed_configuration_types.Empty()) {
     ChromeReportUnrecoverableError();
     std::string error_msg =
         "Configuration failed for types " +
         syncable::ModelTypeSetToString(failed_configuration_types);
-    SyncError error(FROM_HERE, error_msg,
+    csync::SyncError error(FROM_HERE, error_msg,
                     failed_configuration_types.First().Get());
     Abort(UNRECOVERABLE_ERROR, error);
     return;
   }
 
   state_ = CONFIGURING;
   model_association_manager_.StartAssociationAsync();
 }
 
 void DataTypeManagerImpl::OnModelAssociationDone(
     const DataTypeManager::ConfigureResult& result) {
   if (result.status == ABORTED || result.status == UNRECOVERABLE_ERROR) {
     Abort(result.status, result.failed_data_types.size() >= 1 ?
                          result.failed_data_types.front() :
-                         SyncError());
+                         csync::SyncError());
     return;
   }
 
   if (ProcessReconfigure()) {
     return;
   }
 
   if (result.status == CONFIGURE_BLOCKED) {
     failed_datatypes_info_.insert(failed_datatypes_info_.end(),
                                   result.failed_data_types.begin(),
@@ skipping 41 matching lines @@
 
     return;
   }
 
   const bool download_pending = state_ == DOWNLOAD_PENDING;
   state_ = STOPPING;
   if (download_pending) {
     // If Stop() is called while waiting for download, cancel all
     // outstanding tasks.
     weak_ptr_factory_.InvalidateWeakPtrs();
-    Abort(ABORTED, SyncError());
+    Abort(ABORTED, csync::SyncError());
     return;
   }
 
   FinishStop();
 }
 
 void DataTypeManagerImpl::FinishStop() {
   DCHECK(state_== CONFIGURING || state_ == STOPPING || state_ == BLOCKED ||
          state_ == DOWNLOAD_PENDING);
   model_association_manager_.Stop();
 
   failed_datatypes_info_.clear();
   state_ = STOPPED;
 }
 
 void DataTypeManagerImpl::Abort(ConfigureStatus status,
-                                const SyncError& error) {
+                                const csync::SyncError& error) {
   DCHECK_NE(OK, status);
   FinishStop();
-  std::list<SyncError> error_list;
+  std::list<csync::SyncError> error_list;
   if (error.IsSet())
     error_list.push_back(error);
   ConfigureResult result(status,
                          last_requested_types_,
                          error_list,
                          syncable::ModelTypeSet());
   NotifyDone(result);
 }
 
 void DataTypeManagerImpl::NotifyStart() {
@@ skipping 53 matching lines @@
       content::Source<DataTypeManager>(this),
       content::NotificationService::NoDetails());
 }
 
 void DataTypeManagerImpl::AddToConfigureTime() {
   DCHECK(!last_restart_time_.is_null());
   configure_time_delta_ += (base::Time::Now() - last_restart_time_);
 }
 
 }  // namespace browser_sync