chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/history/web_history_service_unittest.cc

 // Copyright 2014 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 "components/history/core/browser/web_history_service.h"
 
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 100 matching lines @@
   // history::Request overrides
   bool IsPending() override { return is_pending_; }
   int GetResponseCode() override { return response_code_; }
   const std::string& GetResponseBody() override { return response_body_; }
   void SetPostData(const std::string& post_data) override {
     post_data_ = post_data;
   }
 
   void Start() override {
     is_pending_ = true;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TestRequest::MimicReturnFromFetch, base::Unretained(this)));
   }
 
   void MimicReturnFromFetch() {
     // Mimic a successful fetch and return. We don't actually send out a request
     // in unittests.
     EXPECT_EQ(web_history_service_->GetExpectedPostData(this), post_data_);
     callback_.Run(this, true);
   }
@@ skipping 88 matching lines @@
         ProfileSyncServiceFactory::GetInstance()->GetForProfile(&profile_));
     EXPECT_CALL(*sync_service,
                 IsSyncActive()).WillRepeatedly(Return(true));
     syncer::ModelTypeSet result;
     result.Put(syncer::HISTORY_DELETE_DIRECTIVES);
     EXPECT_CALL(*sync_service,
                 GetActiveDataTypes()).WillRepeatedly(Return(result));
   }
   void TearDown() override {
     base::RunLoop run_loop;
-    base::MessageLoop::current()->PostTask(FROM_HERE, run_loop.QuitClosure());
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  run_loop.QuitClosure());
     run_loop.Run();
   }
   Profile* profile() { return &profile_; }
 
   ProfileSyncServiceMock* mock_sync_service() {
     return static_cast<ProfileSyncServiceMock*>(
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(&profile_));
   }
 
  private:
 
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
 
   DISALLOW_COPY_AND_ASSIGN(WebHistoryServiceTest);
 };
 
 TEST_F(WebHistoryServiceTest, GetAudioHistoryEnabled) {
   TestingWebHistoryService* web_history_service =
     static_cast<TestingWebHistoryService*>(
     WebHistoryServiceFactory::GetForProfile(profile()));
   EXPECT_TRUE(web_history_service);
 
   web_history_service->SetExpectedURL(
     GURL("https://history.google.com/history/api/lookup?client=audio"));
   web_history_service->SetExpectedAudioHistoryValue(true);
   web_history_service->GetAudioHistoryEnabled(
     base::Bind(&TestingWebHistoryService::GetAudioHistoryCallback,
     base::Unretained(web_history_service)));
-  base::MessageLoop::current()->PostTask(
-    FROM_HERE,
-    base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
-    base::Unretained(web_history_service)));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
+                 base::Unretained(web_history_service)));
 }
 
 TEST_F(WebHistoryServiceTest, SetAudioHistoryEnabledTrue) {
   TestingWebHistoryService* web_history_service =
       static_cast<TestingWebHistoryService*>(
           WebHistoryServiceFactory::GetForProfile(profile()));
   EXPECT_TRUE(web_history_service);
 
   web_history_service->SetExpectedURL(
       GURL("https://history.google.com/history/api/change"));
   web_history_service->SetExpectedAudioHistoryValue(true);
   web_history_service->SetExpectedPostData(
     "{\"client\":\"audio\",\"enable_history_recording\":true}");
   web_history_service->SetAudioHistoryEnabled(
       true,
       base::Bind(&TestingWebHistoryService::SetAudioHistoryCallback,
                  base::Unretained(web_history_service)));
-  base::MessageLoop::current()->PostTask(
-    FROM_HERE,
-    base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
-               base::Unretained(web_history_service)));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
+                 base::Unretained(web_history_service)));
 }
 
 TEST_F(WebHistoryServiceTest, SetAudioHistoryEnabledFalse) {
   TestingWebHistoryService* web_history_service =
     static_cast<TestingWebHistoryService*>(
     WebHistoryServiceFactory::GetForProfile(profile()));
   EXPECT_TRUE(web_history_service);
 
   web_history_service->SetExpectedURL(
     GURL("https://history.google.com/history/api/change"));
   web_history_service->SetExpectedAudioHistoryValue(false);
   web_history_service->SetExpectedPostData(
     "{\"client\":\"audio\",\"enable_history_recording\":false}");
   web_history_service->SetAudioHistoryEnabled(
     false,
     base::Bind(&TestingWebHistoryService::SetAudioHistoryCallback,
     base::Unretained(web_history_service)));
-  base::MessageLoop::current()->PostTask(
-    FROM_HERE,
-    base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
-    base::Unretained(web_history_service)));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
+                 base::Unretained(web_history_service)));
 }
 
 TEST_F(WebHistoryServiceTest, MultipleRequests) {
   TestingWebHistoryService* web_history_service =
     static_cast<TestingWebHistoryService*>(
     WebHistoryServiceFactory::GetForProfile(profile()));
   EXPECT_TRUE(web_history_service);
 
   web_history_service->SetExpectedURL(
     GURL("https://history.google.com/history/api/change"));
   web_history_service->SetExpectedAudioHistoryValue(false);
   web_history_service->SetExpectedPostData(
     "{\"client\":\"audio\",\"enable_history_recording\":false}");
   web_history_service->SetAudioHistoryEnabled(
     false,
     base::Bind(&TestingWebHistoryService::MultipleRequestsCallback,
     base::Unretained(web_history_service)));
 
   web_history_service->SetExpectedURL(
     GURL("https://history.google.com/history/api/lookup?client=audio"));
   web_history_service->SetExpectedPostData("");
   web_history_service->GetAudioHistoryEnabled(
     base::Bind(&TestingWebHistoryService::MultipleRequestsCallback,
     base::Unretained(web_history_service)));
 
   // Check that both requests are no longer pending.
-  base::MessageLoop::current()->PostTask(
-    FROM_HERE,
-    base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
-    base::Unretained(web_history_service)));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
+                 base::Unretained(web_history_service)));
 }
 
 TEST_F(WebHistoryServiceTest, VerifyReadResponse) {
   // Test that properly formatted response with good response code returns true
   // as expected.
   WebHistoryService::CompletionCallback completion_callback;
   scoped_ptr<WebHistoryService::Request> request(
       new TestRequest(
           GURL("http://history.google.com/"),
           completion_callback,
@@ skipping 66 matching lines @@
           "  \"history_recording\": true\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value5;
   // ReadResponse deletes the request
   response_value5 = TestingWebHistoryService::ReadResponse(request5.get());
   enabled_value = true;
   EXPECT_FALSE(response_value5->GetBoolean("history_recording_enabled",
                                            &enabled_value));
   EXPECT_TRUE(enabled_value);
 }