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

chrome/browser/sync/glue/password_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/password_model_associator.h"
 
 #include <set>
 
 #include "base/location.h"
 #include "base/stl_util.h"
@@ skipping 29 matching lines @@
   DCHECK(password_store_);
 #if defined(OS_MACOSX)
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 #else
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 #endif
 }
 
 PasswordModelAssociator::~PasswordModelAssociator() {}
 
-SyncError PasswordModelAssociator::AssociateModels() {
-  SyncError error;
+csync::SyncError PasswordModelAssociator::AssociateModels() {
+  csync::SyncError error;
   DCHECK(expected_loop_ == MessageLoop::current());
   {
     base::AutoLock lock(abort_association_pending_lock_);
     abort_association_pending_ = false;
   }
 
   // We must not be holding a transaction when we interact with the password
   // store, as it can post tasks to the UI thread which can itself be blocked
   // on our transaction, resulting in deadlock. (http://crbug.com/70658)
   std::vector<webkit::forms::PasswordForm*> passwords;
@@ skipping 18 matching lines @@
           FROM_HERE,
           "Server did not create the top-level password node. We "
           "might be running against an out-of-date server.",
           model_type());
     }
 
     for (std::vector<webkit::forms::PasswordForm*>::iterator ix =
              passwords.begin();
          ix != passwords.end(); ++ix) {
       if (IsAbortPending()) {
-        return SyncError();
+        return csync::SyncError();
       }
       std::string tag = MakeTag(**ix);
 
       csync::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncable::PASSWORDS, tag) ==
               csync::BaseNode::INIT_OK) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
@@ skipping 89 matching lines @@
       return false;
     }
     sync_node.Remove();
   }
 
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
-SyncError PasswordModelAssociator::DisassociateModels() {
+csync::SyncError PasswordModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
-  return SyncError();
+  return csync::SyncError();
 }
 
 bool PasswordModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
   int64 password_sync_id;
   if (!GetSyncIdForTaggedNode(kPasswordTag, &password_sync_id)) {
     LOG(ERROR) << "Server did not create the top-level password node. We "
                << "might be running against an out-of-date server.";
     return false;
@@ skipping 71 matching lines @@
 bool PasswordModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
                                                      int64* sync_id) {
   csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   csync::ReadNode sync_node(&trans);
   if (sync_node.InitByTagLookup(tag.c_str()) != csync::BaseNode::INIT_OK)
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
-SyncError PasswordModelAssociator::WriteToPasswordStore(
+csync::SyncError PasswordModelAssociator::WriteToPasswordStore(
     const PasswordVector* new_passwords,
     const PasswordVector* updated_passwords,
     const PasswordVector* deleted_passwords) {
   if (new_passwords) {
     for (PasswordVector::const_iterator password = new_passwords->begin();
          password != new_passwords->end(); ++password) {
       password_store_->AddLoginImpl(*password);
     }
   }
 
   if (updated_passwords) {
     for (PasswordVector::const_iterator password = updated_passwords->begin();
          password != updated_passwords->end(); ++password) {
       password_store_->UpdateLoginImpl(*password);
     }
   }
 
   if (deleted_passwords) {
     for (PasswordVector::const_iterator password = deleted_passwords->begin();
          password != deleted_passwords->end(); ++password) {
       password_store_->RemoveLoginImpl(*password);
     }
   }
 
   if (new_passwords || updated_passwords || deleted_passwords) {
     // We have to notify password store observers of the change by hand since
     // we use internal password store interfaces to make changes synchronously.
     password_store_->PostNotifyLoginsChanged();
   }
-  return SyncError();
+  return csync::SyncError();
 }
 
 // static
 void PasswordModelAssociator::CopyPassword(
         const sync_pb::PasswordSpecificsData& password,
         webkit::forms::PasswordForm* new_password) {
   new_password->scheme =
       static_cast<webkit::forms::PasswordForm::Scheme>(password.scheme());
   new_password->signon_realm = password.signon_realm();
   new_password->origin = GURL(password.origin());
@@ skipping 100 matching lines @@
     const std::string& password_element,
     const std::string& signon_realm) {
   return net::EscapePath(origin_url) + "|" +
          net::EscapePath(username_element) + "|" +
          net::EscapePath(username_value) + "|" +
          net::EscapePath(password_element) + "|" +
          net::EscapePath(signon_realm);
 }
 
 }  // namespace browser_sync