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

chrome/browser/sync/glue/typed_url_model_associator.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/typed_url_model_associator.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/location.h"
@@ skipping 120 matching lines @@
        it != visits.end(); ++it) {
     if (map.count(it->visit_id) == 0 ||
         map[it->visit_id] <= kLastImportedSource) {
       return false;
     }
   }
   // We only saw imported visits, so tell the caller to ignore them.
   return true;
 }
 
-SyncError TypedUrlModelAssociator::AssociateModels() {
+csync::SyncError TypedUrlModelAssociator::AssociateModels() {
   ClearErrorStats();
-  SyncError error = DoAssociateModels();
+  csync::SyncError error = DoAssociateModels();
   UMA_HISTOGRAM_PERCENTAGE("Sync.TypedUrlModelAssociationErrors",
                            GetErrorPercentage());
   ClearErrorStats();
   return error;
 }
 
 void TypedUrlModelAssociator::ClearErrorStats() {
   num_db_accesses_ = 0;
   num_db_errors_ = 0;
 }
 
 int TypedUrlModelAssociator::GetErrorPercentage() const {
   return num_db_accesses_ ? (100 * num_db_errors_ / num_db_accesses_) : 0;
 }
 
-SyncError TypedUrlModelAssociator::DoAssociateModels() {
+csync::SyncError TypedUrlModelAssociator::DoAssociateModels() {
   DVLOG(1) << "Associating TypedUrl Models";
-  SyncError error;
+  csync::SyncError error;
   DCHECK(expected_loop_ == MessageLoop::current());
   if (IsAbortPending())
-    return SyncError();
+    return csync::SyncError();
   history::URLRows typed_urls;
   ++num_db_accesses_;
   if (!history_backend_->GetAllTypedURLs(&typed_urls)) {
     ++num_db_errors_;
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not get the typed_url entries.",
         model_type());
   }
 
   // Get all the visits.
   std::map<history::URLID, history::VisitVector> visit_vectors;
   for (history::URLRows::iterator ix = typed_urls.begin();
        ix != typed_urls.end();) {
     if (IsAbortPending())
-      return SyncError();
+      return csync::SyncError();
     DCHECK_EQ(0U, visit_vectors.count(ix->id()));
     if (!FixupURLAndGetVisits(&(*ix), &(visit_vectors[ix->id()])) ||
         ShouldIgnoreUrl(*ix, visit_vectors[ix->id()])) {
       // Ignore this URL if we couldn't load the visits or if there's some
       // other problem with it (it was empty, or imported and never visited).
       ix = typed_urls.erase(ix);
     } else {
       ++ix;
     }
   }
@@ skipping 11 matching lines @@
           FROM_HERE,
           "Server did not create the top-level typed_url node. We "
           "might be running against an out-of-date server.",
           model_type());
     }
 
     std::set<std::string> current_urls;
     for (history::URLRows::iterator ix = typed_urls.begin();
          ix != typed_urls.end(); ++ix) {
       if (IsAbortPending())
-        return SyncError();
+        return csync::SyncError();
       std::string tag = ix->url().spec();
       // Empty URLs should be filtered out by ShouldIgnoreUrl() previously.
       DCHECK(!tag.empty());
       history::VisitVector& visits = visit_vectors[ix->id()];
 
       csync::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncable::TYPED_URLS, tag) ==
               csync::BaseNode::INIT_OK) {
         // Same URL exists in sync data and in history data - compare the
         // entries to see if there's any difference.
@@ skipping 66 matching lines @@
 
       current_urls.insert(tag);
     }
 
     // Now walk the sync nodes and detect any URLs that exist there, but not in
     // the history DB, so we can add them to our local history DB.
     std::vector<int64> obsolete_nodes;
     int64 sync_child_id = typed_url_root.GetFirstChildId();
     while (sync_child_id != csync::kInvalidId) {
       if (IsAbortPending())
-        return SyncError();
+        return csync::SyncError();
       csync::ReadNode sync_child_node(&trans);
       if (sync_child_node.InitByIdLookup(sync_child_id) !=
               csync::BaseNode::INIT_OK) {
         return error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to fetch child node.",
             model_type());
       }
       const sync_pb::TypedUrlSpecifics& typed_url(
           sync_child_node.GetTypedUrlSpecifics());
@@ skipping 40 matching lines @@
       }
     }
 
     // If we encountered any obsolete nodes, remove them so they don't hang
     // around and confuse people looking at the sync node browser.
     if (!obsolete_nodes.empty()) {
       for (std::vector<int64>::const_iterator it = obsolete_nodes.begin();
            it != obsolete_nodes.end();
            ++it) {
           if (IsAbortPending())
-            return SyncError();
+            return csync::SyncError();
         csync::WriteNode sync_node(&trans);
         if (sync_node.InitByIdLookup(*it) != csync::BaseNode::INIT_OK) {
           return error_handler_->CreateAndUploadError(
               FROM_HERE,
               "Failed to fetch obsolete node.",
               model_type());
         }
         sync_node.Remove();
       }
     }
@@ skipping 81 matching lines @@
             csync::BaseNode::INIT_OK) {
       LOG(ERROR) << "Typed url node lookup failed.";
       return false;
     }
     sync_child_id = sync_child_node.GetSuccessorId();
     sync_child_node.Remove();
   }
   return true;
 }
 
-SyncError TypedUrlModelAssociator::DisassociateModels() {
-  return SyncError();
+csync::SyncError TypedUrlModelAssociator::DisassociateModels() {
+  return csync::SyncError();
 }
 
 void TypedUrlModelAssociator::AbortAssociation() {
   base::AutoLock lock(pending_abort_lock_);
   pending_abort_ = true;
 }
 
 bool TypedUrlModelAssociator::IsAbortPending() {
   base::AutoLock lock(pending_abort_lock_);
   return pending_abort_;
@@ skipping 348 matching lines @@
 bool TypedUrlModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncable::ModelTypeSet encrypted_types =
       csync::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(syncable::TYPED_URLS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync