Remove calls to deprecated MessageLoop methods in sync.

sync/internal_api/http_bridge_unittest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bit_cast.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
@@ skipping 29 matching lines @@
   }
 
   void SetUp() override {
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_IO;
     io_thread_.StartWithOptions(options);
   }
 
   void TearDown() override {
     if (fake_default_request_context_getter_) {
-      GetIOThreadLoop()->ReleaseSoon(FROM_HERE,
-          fake_default_request_context_getter_);
+      GetIOThreadLoop()->task_runner()->ReleaseSoon(
+          FROM_HERE, fake_default_request_context_getter_);
       fake_default_request_context_getter_ = NULL;
     }
     io_thread_.Stop();
   }
 
   HttpBridge* BuildBridge() {
     if (!fake_default_request_context_getter_) {
       fake_default_request_context_getter_ =
           new net::TestURLRequestContextGetter(io_thread_.task_runner());
       fake_default_request_context_getter_->AddRef();
@@ skipping 17 matching lines @@
                                          MAYBE_SyncHttpBridgeTest* test) {
     scoped_refptr<HttpBridge> http_bridge(test->BuildBridge());
     EXPECT_TRUE(test->GetTestRequestContextGetter());
     net::HttpNetworkSession* test_session =
         test->GetTestRequestContextGetter()->GetURLRequestContext()->
         http_transaction_factory()->GetSession();
     EXPECT_EQ(test_session,
               http_bridge->GetRequestContextGetterForTest()->
                   GetURLRequestContext()->
                   http_transaction_factory()->GetSession());
-    main_message_loop->PostTask(FROM_HERE,
-                                base::MessageLoop::QuitWhenIdleClosure());
+    main_message_loop->task_runner()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   base::MessageLoop* GetIOThreadLoop() { return io_thread_.message_loop(); }
 
   // Note this is lazy created, so don't call this before your bridge.
   net::TestURLRequestContextGetter* GetTestRequestContextGetter() {
     return fake_default_request_context_getter_;
   }
 
   net::EmbeddedTestServer test_server_;
@@ skipping 34 matching lines @@
 
  protected:
   void MakeAsynchronousPost() override {
     ASSERT_TRUE(
         test_->GetIOThreadLoop()->task_runner()->BelongsToCurrentThread());
     if (never_finishes_)
       return;
 
     // We don't actually want to make a request for this test, so just callback
     // as if it completed.
-    test_->GetIOThreadLoop()->PostTask(FROM_HERE,
+    test_->GetIOThreadLoop()->task_runner()->PostTask(
+        FROM_HERE,
         base::Bind(&ShuntedHttpBridge::CallOnURLFetchComplete, this));
   }
 
  private:
   ~ShuntedHttpBridge() override {}
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(
         test_->GetIOThreadLoop()->task_runner()->BelongsToCurrentThread());
     // We return a dummy content response.
@@ skipping 27 matching lines @@
     int response_code = 0;
     bridge->MakeSynchronousPost(&os_error, &response_code);
     bridge_for_race_test_ = NULL;
   }
   signal_when_released->Signal();
 }
 
 TEST_F(MAYBE_SyncHttpBridgeTest, TestUsesSameHttpNetworkSession) {
   // Run this test on the IO thread because we can only call
   // URLRequestContextGetter::GetURLRequestContext on the IO thread.
-  io_thread()->message_loop()->PostTask(
+  io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MAYBE_SyncHttpBridgeTest::TestSameHttpNetworkSession,
                  base::MessageLoop::current(), this));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 }
 
 // Test the HttpBridge without actually making any network requests.
 TEST_F(MAYBE_SyncHttpBridgeTest, TestMakeSynchronousPostShunted) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<HttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, false));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
@@ skipping 191 matching lines @@
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   // First, block the sync thread on the post.
   base::WaitableEvent signal_when_created(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent signal_when_released(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
-  sync_thread.message_loop()->PostTask(FROM_HERE,
+  sync_thread.task_runner()->PostTask(
+      FROM_HERE,
       base::Bind(&MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest,
-                 base::Unretained(this),
-                 &signal_when_created,
+                 base::Unretained(this), &signal_when_created,
                  &signal_when_released));
 
   // Stop IO so we can control order of operations.
   base::WaitableEvent io_waiter(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
@@ skipping 76 matching lines @@
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent wait_for_shutdown(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CancelationSignal release_request_context_signal;
 
   // Create bridge factory and factory on sync thread and wait for the creation
   // to finish.
-  sync_thread.message_loop()->PostTask(
+  sync_thread.task_runner()->PostTask(
       FROM_HERE, base::Bind(&HttpBridgeRunOnSyncThread,
                             base::Unretained(baseline_context_getter.get()),
                             &release_request_context_signal, &factory, &bridge,
                             &signal_when_created, &wait_for_shutdown));
   signal_when_created.Wait();
 
   // Simulate sync shutdown by aborting bridge and shutting down factory on
   // frontend.
   bridge->Abort();
   release_request_context_signal.Signal();
 
   // Wait for sync's RequestContextGetter to be cleared on IO thread and
   // check for reference count.
   base::WaitableEvent signal_wait_start(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent wait_done(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
-  io_thread()->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&WaitOnIOThread, &signal_wait_start, &wait_done));
+  io_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&WaitOnIOThread, &signal_wait_start, &wait_done));
   signal_wait_start.Wait();
   // |baseline_context_getter| should have only one reference from local
   // variable.
   EXPECT_TRUE(baseline_context_getter->HasOneRef());
   baseline_context_getter = NULL;
 
   // Unblock and stop IO thread before sync thread.
   wait_done.Signal();
   io_thread()->Stop();
 
@@ skipping 24 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer