Migrate callers of message_loop_proxy() to task_runner()

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 "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
@@ skipping 35 matching lines @@
       GetIOThreadLoop()->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_.message_loop_proxy());
+          new net::TestURLRequestContextGetter(io_thread_.task_runner());
       fake_default_request_context_getter_->AddRef();
     }
     HttpBridge* bridge =
         new HttpBridge(kUserAgent,
                        fake_default_request_context_getter_,
                        NetworkTimeUpdateCallback());
     return bridge;
   }
 
   static void Abort(HttpBridge* bridge) {
@@ skipping 85 matching lines @@
     OnURLFetchComplete(&fetcher);
   }
   SyncHttpBridgeTest* test_;
   bool never_finishes_;
 };
 
 void SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* signal_when_released) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
-      new net::TestURLRequestContextGetter(io_thread_.message_loop_proxy()));
+      new net::TestURLRequestContextGetter(io_thread_.task_runner()));
   {
     scoped_refptr<ShuntedHttpBridge> bridge(
         new ShuntedHttpBridge(ctx_getter.get(), this, true));
     bridge->SetURL("http://www.google.com", 9999);
     bridge->SetPostPayload("text/plain", 2, " ");
     bridge_for_race_test_ = bridge.get();
     signal_when_created->Signal();
 
     int os_error = 0;
     int response_code = 0;
@@ skipping 10 matching lines @@
       ->PostTask(FROM_HERE,
                  base::Bind(&SyncHttpBridgeTest::TestSameHttpNetworkSession,
                             base::MessageLoop::current(),
                             this));
   base::MessageLoop::current()->Run();
 }
 
 // Test the HttpBridge without actually making any network requests.
 TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostShunted) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
-      new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
+      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, " ");
 
   int os_error = 0;
   int response_code = 0;
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_TRUE(success);
   EXPECT_EQ(200, response_code);
@@ skipping 103 matching lines @@
   EXPECT_TRUE(success);
   EXPECT_EQ(200, response_code);
   EXPECT_EQ(0, os_error);
 
   EXPECT_EQ(http_bridge->GetResponseHeaderValue("Content-type"), "text/html");
   EXPECT_TRUE(http_bridge->GetResponseHeaderValue("invalid-header").empty());
 }
 
 TEST_F(SyncHttpBridgeTest, Abort) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
-      new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
+      new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<ShuntedHttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, true));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
 
   int os_error = 0;
   int response_code = 0;
 
-  io_thread()->message_loop_proxy()->PostTask(
+  io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SyncHttpBridgeTest::Abort, http_bridge));
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_FALSE(success);
   EXPECT_EQ(net::ERR_ABORTED, os_error);
 }
 
 TEST_F(SyncHttpBridgeTest, AbortLate) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
-      new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
+      new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<ShuntedHttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, false));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
 
   int os_error = 0;
   int response_code = 0;
 
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   ASSERT_TRUE(success);
@@ skipping 13 matching lines @@
   base::WaitableEvent signal_when_created(false, false);
   base::WaitableEvent signal_when_released(false, false);
   sync_thread.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncHttpBridgeTest::RunSyncThreadBridgeUseTest,
                  base::Unretained(this),
                  &signal_when_created,
                  &signal_when_released));
 
   // Stop IO so we can control order of operations.
   base::WaitableEvent io_waiter(false, false);
-  ASSERT_TRUE(io_thread()->message_loop_proxy()->PostTask(
+  ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
   signal_when_created.Wait();  // Wait till we have a bridge to abort.
   ASSERT_TRUE(bridge_for_race_test());
 
   // Schedule the fetch completion callback (but don't run it yet). Don't take
   // a reference to the bridge to mimic URLFetcher's handling of the delegate.
   net::URLFetcherDelegate* delegate =
       static_cast<net::URLFetcherDelegate*>(bridge_for_race_test());
   net::ResponseCookies cookies;
   std::string response_content = "success!";
   net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
   fetcher.set_response_code(200);
   fetcher.set_cookies(cookies);
   fetcher.SetResponseString(response_content);
-  ASSERT_TRUE(io_thread()->message_loop_proxy()->PostTask(
+  ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&net::URLFetcherDelegate::OnURLFetchComplete,
           base::Unretained(delegate), &fetcher)));
 
   // Abort the fetch. This should be smart enough to handle the case where
   // the bridge is destroyed before the callback scheduled above completes.
   bridge_for_race_test()->Abort();
 
   // Wait until the sync thread releases its ref on the bridge.
   signal_when_released.Wait();
@@ skipping 41 matching lines @@
 // Tests RequestContextGetter is properly released on IO thread even when
 // IO thread stops before sync thread.
 TEST_F(SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   syncer::HttpPostProviderFactory* factory = NULL;
   syncer::HttpPostProviderInterface* bridge = NULL;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
-      new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
+      new net::TestURLRequestContextGetter(io_thread()->task_runner()));
 
   base::WaitableEvent signal_when_created(false, false);
   base::WaitableEvent wait_for_shutdown(false, false);
 
   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(FROM_HERE,
       base::Bind(&HttpBridgeRunOnSyncThread,
@@ skipping 29 matching lines @@
   sync_thread.Stop();
 }
 
 // Attempt to release the URLRequestContextGetter before the HttpBridgeFactory
 // is initialized.
 TEST_F(SyncHttpBridgeTest, EarlyAbortFactory) {
   // In a real scenario, the following would happen on many threads.  For
   // simplicity, this test uses only one thread.
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
-      new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
+      new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   CancelationSignal release_request_context_signal;
 
   // UI Thread: Initialize the HttpBridgeFactory.  The next step would be to
   // post a task to SBH::Core to have it initialized.
   scoped_ptr<syncer::HttpBridgeFactory> factory(
       new HttpBridgeFactory(baseline_context_getter.get(),
                             NetworkTimeUpdateCallback(),
                             &release_request_context_signal));
 
   // UI Thread: A very early shutdown request arrives and executes on the UI
   // thread before the posted sync thread task is run.
   release_request_context_signal.Signal();
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent");
 
   // 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