[Sync] Rename csync namespace to syncer

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 14 matching lines @@
 namespace browser_sync {
 
 const char kPasswordTag[] = "google_chrome_passwords";
 
 PasswordModelAssociator::PasswordModelAssociator(
     ProfileSyncService* sync_service,
     PasswordStore* password_store,
     DataTypeErrorHandler* error_handler)
     : sync_service_(sync_service),
       password_store_(password_store),
-      password_node_id_(csync::kInvalidId),
+      password_node_id_(syncer::kInvalidId),
       abort_association_pending_(false),
       expected_loop_(MessageLoop::current()),
       error_handler_(error_handler) {
   DCHECK(sync_service_);
   DCHECK(password_store_);
 #if defined(OS_MACOSX)
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 #else
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 #endif
 }
 
 PasswordModelAssociator::~PasswordModelAssociator() {}
 
-csync::SyncError PasswordModelAssociator::AssociateModels() {
-  csync::SyncError error;
+syncer::SyncError PasswordModelAssociator::AssociateModels() {
+  syncer::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;
   if (!password_store_->FillAutofillableLogins(&passwords) ||
       !password_store_->FillBlacklistLogins(&passwords)) {
     STLDeleteElements(&passwords);
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not get the password entries.",
         model_type());
   }
 
   std::set<std::string> current_passwords;
   PasswordVector new_passwords;
   PasswordVector updated_passwords;
   {
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode password_root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode password_root(&trans);
     if (password_root.InitByTagLookup(kPasswordTag) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           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 csync::SyncError();
+        return syncer::SyncError();
       }
       std::string tag = MakeTag(**ix);
 
-      csync::ReadNode node(&trans);
+      syncer::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncable::PASSWORDS, tag) ==
-              csync::BaseNode::INIT_OK) {
+              syncer::BaseNode::INIT_OK) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
         webkit::forms::PasswordForm new_password;
 
         if (MergePasswords(password, **ix, &new_password)) {
-          csync::WriteNode write_node(&trans);
+          syncer::WriteNode write_node(&trans);
           if (write_node.InitByClientTagLookup(syncable::PASSWORDS, tag) !=
-                  csync::BaseNode::INIT_OK) {
+                  syncer::BaseNode::INIT_OK) {
             STLDeleteElements(&passwords);
             return error_handler_->CreateAndUploadError(
                 FROM_HERE,
                 "Failed to edit password sync node.",
                 model_type());
           }
           WriteToSyncNode(new_password, &write_node);
           updated_passwords.push_back(new_password);
         }
 
         Associate(&tag, node.GetId());
       } else {
-        csync::WriteNode node(&trans);
-        csync::WriteNode::InitUniqueByCreationResult result =
+        syncer::WriteNode node(&trans);
+        syncer::WriteNode::InitUniqueByCreationResult result =
             node.InitUniqueByCreation(syncable::PASSWORDS, password_root, tag);
-        if (result != csync::WriteNode::INIT_SUCCESS) {
+        if (result != syncer::WriteNode::INIT_SUCCESS) {
           STLDeleteElements(&passwords);
           return error_handler_->CreateAndUploadError(
               FROM_HERE,
               "Failed to create password sync node.",
               model_type());
         }
 
         WriteToSyncNode(**ix, &node);
 
         Associate(&tag, node.GetId());
       }
 
       current_passwords.insert(tag);
     }
 
     STLDeleteElements(&passwords);
 
     int64 sync_child_id = password_root.GetFirstChildId();
-    while (sync_child_id != csync::kInvalidId) {
-      csync::ReadNode sync_child_node(&trans);
+    while (sync_child_id != syncer::kInvalidId) {
+      syncer::ReadNode sync_child_node(&trans);
       if (sync_child_node.InitByIdLookup(sync_child_id) !=
-              csync::BaseNode::INIT_OK) {
+              syncer::BaseNode::INIT_OK) {
         return error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to fetch child node.",
             model_type());
       }
       const sync_pb::PasswordSpecificsData& password =
           sync_child_node.GetPasswordSpecifics();
       std::string tag = MakeTag(password);
 
       // The password only exists on the server.  Add it to the local
@@ skipping 17 matching lines @@
                                &updated_passwords,
                                NULL);
   if (error.IsSet()) {
     return error;
   }
 
   return error;
 }
 
 bool PasswordModelAssociator::DeleteAllNodes(
-    csync::WriteTransaction* trans) {
+    syncer::WriteTransaction* trans) {
   DCHECK(expected_loop_ == MessageLoop::current());
   for (PasswordToSyncIdMap::iterator node_id = id_map_.begin();
        node_id != id_map_.end(); ++node_id) {
-    csync::WriteNode sync_node(trans);
+    syncer::WriteNode sync_node(trans);
     if (sync_node.InitByIdLookup(node_id->second) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       LOG(ERROR) << "Typed url node lookup failed.";
       return false;
     }
     sync_node.Remove();
   }
 
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
-csync::SyncError PasswordModelAssociator::DisassociateModels() {
+syncer::SyncError PasswordModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
-  return csync::SyncError();
+  return syncer::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;
   }
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
-  csync::ReadNode password_node(&trans);
+  syncer::ReadNode password_node(&trans);
   if (password_node.InitByIdLookup(password_sync_id) !=
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     LOG(ERROR) << "Server did not create the top-level password node. We "
                << "might be running against an out-of-date server.";
     return false;
   }
 
   // The sync model has user created nodes if the password folder has any
   // children.
   *has_nodes = password_node.HasChildren();
   return true;
 }
 
 void PasswordModelAssociator::AbortAssociation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(abort_association_pending_lock_);
   abort_association_pending_ = true;
 }
 
 bool PasswordModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   // We always encrypt passwords, so no need to check if encryption is enabled.
   return sync_service_->IsCryptographerReady(&trans);
 }
 
 const std::string* PasswordModelAssociator::GetChromeNodeFromSyncId(
     int64 sync_id) {
   return NULL;
 }
 
 bool PasswordModelAssociator::InitSyncNodeFromChromeId(
     const std::string& node_id,
-    csync::BaseNode* sync_node) {
+    syncer::BaseNode* sync_node) {
   return false;
 }
 
 bool PasswordModelAssociator::IsAbortPending() {
   base::AutoLock lock(abort_association_pending_lock_);
   return abort_association_pending_;
 }
 
 int64 PasswordModelAssociator::GetSyncIdFromChromeId(
     const std::string& password) {
   PasswordToSyncIdMap::const_iterator iter = id_map_.find(password);
-  return iter == id_map_.end() ? csync::kInvalidId : iter->second;
+  return iter == id_map_.end() ? syncer::kInvalidId : iter->second;
 }
 
 void PasswordModelAssociator::Associate(
     const std::string* password, int64 sync_id) {
   DCHECK(expected_loop_ == MessageLoop::current());
-  DCHECK_NE(csync::kInvalidId, sync_id);
+  DCHECK_NE(syncer::kInvalidId, sync_id);
   DCHECK(id_map_.find(*password) == id_map_.end());
   DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end());
   id_map_[*password] = sync_id;
   id_map_inverse_[sync_id] = *password;
 }
 
 void PasswordModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(expected_loop_ == MessageLoop::current());
   SyncIdToPasswordMap::iterator iter = id_map_inverse_.find(sync_id);
   if (iter == id_map_inverse_.end())
     return;
   CHECK(id_map_.erase(iter->second));
   id_map_inverse_.erase(iter);
 }
 
 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)
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadNode sync_node(&trans);
+  if (sync_node.InitByTagLookup(tag.c_str()) != syncer::BaseNode::INIT_OK)
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
-csync::SyncError PasswordModelAssociator::WriteToPasswordStore(
+syncer::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 csync::SyncError();
+  return syncer::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 47 matching lines @@
   } else {
     CopyPassword(password, new_password);
   }
 
   return true;
 }
 
 // static
 void PasswordModelAssociator::WriteToSyncNode(
          const webkit::forms::PasswordForm& password_form,
-         csync::WriteNode* node) {
+         syncer::WriteNode* node) {
   sync_pb::PasswordSpecificsData password;
   password.set_scheme(password_form.scheme);
   password.set_signon_realm(password_form.signon_realm);
   password.set_origin(password_form.origin.spec());
   password.set_action(password_form.action.spec());
   password.set_username_element(UTF16ToUTF8(password_form.username_element));
   password.set_password_element(UTF16ToUTF8(password_form.password_element));
   password.set_username_value(UTF16ToUTF8(password_form.username_value));
   password.set_password_value(UTF16ToUTF8(password_form.password_value));
   password.set_ssl_valid(password_form.ssl_valid);
@@ skipping 32 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