chrome: Use base::MessageLoop. (Part 3)

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 16 matching lines @@
 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_(syncer::kInvalidId),
       abort_association_pending_(false),
-      expected_loop_(MessageLoop::current()),
+      expected_loop_(base::MessageLoop::current()),
       error_handler_(error_handler) {
   DCHECK(sync_service_);
 #if defined(OS_MACOSX)
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 #else
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 #endif
 }
 
 PasswordModelAssociator::~PasswordModelAssociator() {}
 
 syncer::SyncError PasswordModelAssociator::AssociateModels(
     syncer::SyncMergeResult* local_merge_result,
     syncer::SyncMergeResult* syncer_merge_result) {
   syncer::SyncError error;
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::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<content::PasswordForm*> passwords;
   if (!password_store_->FillAutofillableLogins(&passwords) ||
@@ skipping 110 matching lines @@
                                NULL);
   if (error.IsSet()) {
     return error;
   }
 
   return error;
 }
 
 bool PasswordModelAssociator::DeleteAllNodes(
     syncer::WriteTransaction* trans) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   for (PasswordToSyncIdMap::iterator node_id = id_map_.begin();
-       node_id != id_map_.end(); ++node_id) {
+       node_id != id_map_.end();
+       ++node_id) {
     syncer::WriteNode sync_node(trans);
     if (sync_node.InitByIdLookup(node_id->second) !=
             syncer::BaseNode::INIT_OK) {
       LOG(ERROR) << "Typed url node lookup failed.";
       return false;
     }
     sync_node.Tombstone();
   }
 
   id_map_.clear();
@@ skipping 62 matching lines @@
 }
 
 int64 PasswordModelAssociator::GetSyncIdFromChromeId(
     const std::string& password) {
   PasswordToSyncIdMap::const_iterator iter = id_map_.find(password);
   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(expected_loop_ == base::MessageLoop::current());
   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());
+  DCHECK(expected_loop_ == base::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) {
   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
@@ skipping 148 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