Remove calls to deprecated MessageLoop methods in chrome.

chrome/browser/history/android/android_history_provider_service_unittest.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/android/android_history_provider_service.h"
 
 #include <stdint.h>
 
+#include "base/callback.h"
 #include "base/macros.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/history/core/browser/android/android_history_types.h"
@@ skipping 76 matching lines @@
   }
 
   int cursor_position() const {
     return cursor_position_;
   }
 
   int count() const {
     return count_;
   }
 
+  void set_quit_when_idle_closure(const base::Closure& quit_when_idle_closure) {
+    quit_when_idle_closure_ = quit_when_idle_closure;
+  }
+
   void OnInserted(int64_t id) {
     success_ = id != 0;
-    base::MessageLoop::current()->QuitWhenIdle();
+    quit_when_idle_closure_.Run();
   }
 
   void OnQueryResult(AndroidStatement* statement) {
     success_ = statement != nullptr;
     statement_ = statement;
-    base::MessageLoop::current()->QuitWhenIdle();
+    quit_when_idle_closure_.Run();
   }
 
   void OnUpdated(int count) {
     success_ = count != 0;
     count_ = count;
-    base::MessageLoop::current()->QuitWhenIdle();
+    quit_when_idle_closure_.Run();
   }
 
   void OnDeleted(int count) {
     success_ = count != 0;
     count_ = count;
-    base::MessageLoop::current()->QuitWhenIdle();
+    quit_when_idle_closure_.Run();
   }
 
   void OnStatementMoved(int cursor_position) {
     cursor_position_ = cursor_position;
-    base::MessageLoop::current()->QuitWhenIdle();
+    quit_when_idle_closure_.Run();
   }
 
  private:
   friend class base::RefCountedThreadSafe<CallbackHelper>;
   ~CallbackHelper() {
   }
 
   bool success_;
   AndroidStatement* statement_;
   int cursor_position_;
   int count_;
+  base::Closure quit_when_idle_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
+void RunMessageLoop(CallbackHelper* callback_helper) {
+  ASSERT_TRUE(callback_helper);
+  base::RunLoop run_loop;
+  callback_helper->set_quit_when_idle_closure(run_loop.QuitWhenIdleClosure());
+  run_loop.Run();
+  callback_helper->set_quit_when_idle_closure(base::Closure());
+}
+
 TEST_F(AndroidHistoryProviderServiceTest, TestHistoryAndBookmark) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://www.google.com");
   row.set_url(GURL("http://www.google.com"));
 
   scoped_refptr<CallbackHelper> callback(new CallbackHelper());
 
   // Insert a row and verify it succeeded.
   service_->InsertHistoryAndBookmark(
       row,
       Bind(&CallbackHelper::OnInserted, callback.get()),
       &cancelable_tracker_);
 
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
 
   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
   projections.push_back(HistoryAndBookmarkRow::ID);
 
   // Query the inserted row.
   service_->QueryHistoryAndBookmarks(
       projections,
       std::string(),
       std::vector<base::string16>(),
       std::string(),
       Bind(&CallbackHelper::OnQueryResult, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   ASSERT_TRUE(callback->success());
 
   // Move the cursor to the begining and verify whether we could get
   // the same result.
   AndroidStatement* statement = callback->statement();
   service_->MoveStatement(
       statement,
       0,
       -1,
       Bind(&CallbackHelper::OnStatementMoved, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_EQ(-1, callback->cursor_position());
   EXPECT_TRUE(callback->statement()->statement()->Step());
   EXPECT_FALSE(callback->statement()->statement()->Step());
   service_->CloseStatement(statement);
 
   // Update the row.
   HistoryAndBookmarkRow update_row;
   update_row.set_visit_count(3);
   service_->UpdateHistoryAndBookmarks(
       update_row,
       std::string(),
       std::vector<base::string16>(),
       Bind(&CallbackHelper::OnUpdated, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
   EXPECT_EQ(1, callback->count());
 
   // Delete the row.
   service_->DeleteHistoryAndBookmarks(
       std::string(),
       std::vector<base::string16>(),
       Bind(&CallbackHelper::OnDeleted, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
   EXPECT_EQ(1, callback->count());
 }
 
 TEST_F(AndroidHistoryProviderServiceTest, TestSearchTerm) {
   SearchRow search_row;
   search_row.set_search_term(base::UTF8ToUTF16("google"));
   search_row.set_url(GURL("http://google.com"));
   search_row.set_keyword_id(1);
   search_row.set_search_time(Time::Now());
 
   scoped_refptr<CallbackHelper> callback(new CallbackHelper());
 
   // Insert a row and verify it succeeded.
   service_->InsertSearchTerm(search_row,
                              Bind(&CallbackHelper::OnInserted, callback.get()),
                              &cancelable_tracker_);
 
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
 
   std::vector<SearchRow::ColumnID> projections;
   projections.push_back(SearchRow::ID);
 
   // Query the inserted row.
   service_->QuerySearchTerms(
       projections,
       std::string(),
       std::vector<base::string16>(),
       std::string(),
       Bind(&CallbackHelper::OnQueryResult, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   ASSERT_TRUE(callback->success());
 
   // Move the cursor to the begining and verify whether we could get
   // the same result.
   AndroidStatement* statement = callback->statement();
   service_->MoveStatement(
       statement,
       0,
       -1,
       Bind(&CallbackHelper::OnStatementMoved, callback.get()),
       &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_EQ(-1, callback->cursor_position());
   EXPECT_TRUE(callback->statement()->statement()->Step());
   EXPECT_FALSE(callback->statement()->statement()->Step());
   service_->CloseStatement(statement);
 
   // Update the row.
   SearchRow update_row;
   update_row.set_search_time(Time::Now());
   service_->UpdateSearchTerms(update_row,
                               std::string(),
                               std::vector<base::string16>(),
                               Bind(&CallbackHelper::OnUpdated, callback.get()),
                               &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
   EXPECT_EQ(1, callback->count());
 
   // Delete the row.
   service_->DeleteSearchTerms(std::string(),
                               std::vector<base::string16>(),
                               Bind(&CallbackHelper::OnDeleted, callback.get()),
                               &cancelable_tracker_);
-  base::MessageLoop::current()->Run();
+  RunMessageLoop(callback.get());
   EXPECT_TRUE(callback->success());
   EXPECT_EQ(1, callback->count());
 }
 
 }  // namespace