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

chrome/browser/history/history_backend.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/history/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 210 matching lines @@
   virtual int OnError(int error,
                       sql::Connection* connection,
                       sql::Statement* stmt) OVERRIDE {
     // Do not schedule killing database more than once. If the first time
     // failed, it is unlikely that a second time will be successful.
     if (!scheduled_killing_database_ && sql::IsErrorCatastrophic(error)) {
       scheduled_killing_database_ = true;
 
       // Don't just do the close/delete here, as we are being called by |db| and
       // that seems dangerous.
-      MessageLoop::current()->PostTask(
+      base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&HistoryBackend::KillHistoryDatabase, backend_));
     }
 
     return error;
   }
 
   // Returns true if the delegate has previously scheduled killing the database.
   bool scheduled_killing_database() const {
     return scheduled_killing_database_;
@@ skipping 49 matching lines @@
   file_util::Delete(GetAndroidCacheFileName(), false);
 #endif
 }
 
 void HistoryBackend::Init(const std::string& languages, bool force_fail) {
   if (!force_fail)
     InitImpl(languages);
   delegate_->DBLoaded(id_);
 }
 
-void HistoryBackend::SetOnBackendDestroyTask(MessageLoop* message_loop,
+void HistoryBackend::SetOnBackendDestroyTask(base::MessageLoop* message_loop,
                                              const base::Closure& task) {
   if (!backend_destroy_task_.is_null())
     DLOG(WARNING) << "Setting more than one destroy task, overriding";
   backend_destroy_message_loop_ = message_loop;
   backend_destroy_task_ = task;
 }
 
 void HistoryBackend::Closing() {
   // Any scheduled commit will have a reference to us, we must make it
   // release that reference before we can be destroyed.
@@ skipping 879 matching lines @@
     return;
 
   if (db_.get()) {
     db_->QuerySegmentUsage(from_time, max_result_count, &request->value.get());
 
     // If this is the first time we query segments, invoke
     // DeleteOldSegmentData asynchronously. We do this to cleanup old
     // entries.
     if (!segment_queried_) {
       segment_queried_ = true;
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&HistoryBackend::DeleteOldSegmentData, this));
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&HistoryBackend::DeleteOldSegmentData, this));
     }
   }
   request->ForwardResult(request->handle(), &request->value.get());
 }
 
 void HistoryBackend::IncreaseSegmentDuration(const GURL& url,
                                              base::Time time,
                                              base::TimeDelta delta) {
   if (!db_.get())
     return;
@@ skipping 1407 matching lines @@
   if (text_database_.get()) {
     text_database_->CommitTransaction();
     text_database_->BeginTransaction();
   }
 }
 
 void HistoryBackend::ScheduleCommit() {
   if (scheduled_commit_.get())
     return;
   scheduled_commit_ = new CommitLaterTask(this);
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CommitLaterTask::RunCommit, scheduled_commit_.get()),
       base::TimeDelta::FromSeconds(kCommitIntervalSeconds));
 }
 
 void HistoryBackend::CancelScheduledCommit() {
   if (scheduled_commit_) {
     scheduled_commit_->Cancel();
     scheduled_commit_ = NULL;
   }
@@ skipping 19 matching lines @@
   db_task_requests_.pop_front();
   if (request->value->RunOnDBThread(this, db_.get())) {
     // The task is done. Notify the callback.
     request->ForwardResult();
     // We AddRef'd the request before adding, need to release it now.
     request->Release();
   } else {
     // Tasks wants to run some more. Schedule it at the end of current tasks.
     db_task_requests_.push_back(request);
     // And process it after an invoke later.
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTaskImpl, this));
   }
 }
 
 void HistoryBackend::ReleaseDBTasks() {
   for (std::list<HistoryDBTaskRequest*>::iterator i =
        db_task_requests_.begin(); i != db_task_requests_.end(); ++i) {
     (*i)->Release();
   }
   db_task_requests_.clear();
@@ skipping 385 matching lines @@
   info.url_id = visit.url_id;
   info.time = visit.visit_time;
   info.transition = visit.transition;
   // If we don't have a delegate yet during setup or shutdown, we will drop
   // these notifications.
   if (delegate_.get())
     delegate_->NotifyVisitDBObserversOnAddVisit(info);
 }
 
 }  // namespace history