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

chrome/browser/sync/glue/password_change_processor.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_change_processor.h"
 
 #include <string>
 
 #include "base/location.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
 
 namespace browser_sync {
 
 PasswordChangeProcessor::PasswordChangeProcessor(
     PasswordModelAssociator* model_associator,
     PasswordStore* password_store,
     DataTypeErrorHandler* error_handler)
     : ChangeProcessor(error_handler),
       model_associator_(model_associator),
       password_store_(password_store),
-      expected_loop_(MessageLoop::current()) {
+      expected_loop_(base::MessageLoop::current()) {
   DCHECK(model_associator);
   DCHECK(error_handler);
 #if defined(OS_MACOSX)
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 #else
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 #endif
 }
 
 PasswordChangeProcessor::~PasswordChangeProcessor() {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 }
 
 void PasswordChangeProcessor::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   DCHECK(chrome::NOTIFICATION_LOGINS_CHANGED == type);
 
   syncer::WriteTransaction trans(FROM_HERE, share_handle());
 
   syncer::ReadNode password_root(&trans);
   if (password_root.InitByTagLookup(kPasswordTag) !=
           syncer::BaseNode::INIT_OK) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
         "Server did not create the top-level password node. "
         "We might be running against an out-of-date server.");
@@ skipping 87 matching lines @@
         break;
       }
     }
   }
 }
 
 void PasswordChangeProcessor::ApplyChangesFromSyncModel(
     const syncer::BaseTransaction* trans,
     int64 model_version,
     const syncer::ImmutableChangeRecordList& changes) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 
   syncer::ReadNode password_root(trans);
   if (password_root.InitByTagLookup(kPasswordTag) !=
           syncer::BaseNode::INIT_OK) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
         "Password root node lookup failed.");
     return;
   }
 
   DCHECK(deleted_passwords_.empty() && new_passwords_.empty() &&
@@ skipping 37 matching lines @@
       model_associator_->Associate(&tag, sync_node.GetId());
       new_passwords_.push_back(password);
     } else {
       DCHECK_EQ(syncer::ChangeRecord::ACTION_UPDATE, it->action);
       updated_passwords_.push_back(password);
     }
   }
 }
 
 void PasswordChangeProcessor::CommitChangesFromSyncModel() {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   ScopedStopObserving<PasswordChangeProcessor> stop_observing(this);
 
   syncer::SyncError error = model_associator_->WriteToPasswordStore(
       &new_passwords_,
       &updated_passwords_,
       &deleted_passwords_);
   if (error.IsSet()) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
         "Error writing passwords");
     return;
   }
 
   deleted_passwords_.clear();
   new_passwords_.clear();
   updated_passwords_.clear();
 }
 
 void PasswordChangeProcessor::StartImpl(Profile* profile) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   StartObserving();
 }
 
 void PasswordChangeProcessor::StartObserving() {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_LOGINS_CHANGED,
                               content::Source<PasswordStore>(password_store_));
 }
 
 void PasswordChangeProcessor::StopObserving() {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   notification_registrar_.Remove(
       this,
       chrome::NOTIFICATION_LOGINS_CHANGED,
       content::Source<PasswordStore>(password_store_));
 }
 
 }  // namespace browser_sync