sync: Use base::MessageLoop.

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/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/test/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
@@ skipping 15 matching lines @@
       : test_server_(net::SpawnedTestServer::TYPE_HTTP,
                      net::SpawnedTestServer::kLocalhost,
                      base::FilePath(kDocRoot)),
         fake_default_request_context_getter_(NULL),
         bridge_for_race_test_(NULL),
         io_thread_("IO thread") {
   }
 
   virtual void SetUp() {
     base::Thread::Options options;
-    options.message_loop_type = MessageLoop::TYPE_IO;
+    options.message_loop_type = base::MessageLoop::TYPE_IO;
     io_thread_.StartWithOptions(options);
   }
 
   virtual void TearDown() {
     if (fake_default_request_context_getter_) {
       GetIOThreadLoop()->ReleaseSoon(FROM_HERE,
           fake_default_request_context_getter_);
       fake_default_request_context_getter_ = NULL;
     }
     io_thread_.Stop();
@@ skipping 15 matching lines @@
 
   static void Abort(HttpBridge* bridge) {
     bridge->Abort();
   }
 
   // Used by AbortAndReleaseBeforeFetchCompletes to test an interesting race
   // condition.
   void RunSyncThreadBridgeUseTest(base::WaitableEvent* signal_when_created,
                                   base::WaitableEvent* signal_when_released);
 
-  static void TestSameHttpNetworkSession(MessageLoop* main_message_loop,
+  static void TestSameHttpNetworkSession(base::MessageLoop* main_message_loop,
                                          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, MessageLoop::QuitClosure());
+    main_message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
 
-  MessageLoop* GetIOThreadLoop() {
-    return io_thread_.message_loop();
-  }
+  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::SpawnedTestServer test_server_;
 
   base::Thread* io_thread() { return &io_thread_; }
 
   HttpBridge* bridge_for_race_test() { return bridge_for_race_test_; }
 
  private:
   // A make-believe "default" request context, as would be returned by
   // Profile::GetDefaultRequestContext().  Created lazily by BuildBridge.
   net::TestURLRequestContextGetter* fake_default_request_context_getter_;
 
   HttpBridge* bridge_for_race_test_;
 
   // Separate thread for IO used by the HttpBridge.
   base::Thread io_thread_;
-  MessageLoop loop_;
+  base::MessageLoop loop_;
 };
 
 // An HttpBridge that doesn't actually make network requests and just calls
 // back with dummy response info.
 // TODO(tim): Instead of inheriting here we should inject a component
 // responsible for the MakeAsynchronousPost bit.
 class ShuntedHttpBridge : public HttpBridge {
  public:
   // If |never_finishes| is true, the simulated request never actually
   // returns.
   ShuntedHttpBridge(net::URLRequestContextGetter* baseline_context_getter,
                     SyncHttpBridgeTest* test, bool never_finishes)
       : HttpBridge(
           new HttpBridge::RequestContextGetter(
               baseline_context_getter, "user agent"),
           NetworkTimeUpdateCallback()),
         test_(test), never_finishes_(never_finishes) { }
  protected:
   virtual void MakeAsynchronousPost() OVERRIDE {
-    ASSERT_TRUE(MessageLoop::current() == test_->GetIOThreadLoop());
+    ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
     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,
         base::Bind(&ShuntedHttpBridge::CallOnURLFetchComplete, this));
   }
  private:
   virtual ~ShuntedHttpBridge() {}
 
   void CallOnURLFetchComplete() {
-    ASSERT_TRUE(MessageLoop::current() == test_->GetIOThreadLoop());
+    ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
     // We return no cookies and a dummy content response.
     net::ResponseCookies cookies;
 
     std::string response_content = "success!";
     net::TestURLFetcher fetcher(0, GURL(), NULL);
     fetcher.set_url(GURL("www.google.com"));
     fetcher.set_response_code(200);
     fetcher.set_cookies(cookies);
     fetcher.SetResponseString(response_content);
     OnURLFetchComplete(&fetcher);
@@ skipping 19 matching lines @@
     int response_code = 0;
     bridge->MakeSynchronousPost(&os_error, &response_code);
     bridge_for_race_test_ = NULL;
   }
   signal_when_released->Signal();
 }
 
 TEST_F(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(
-      FROM_HERE,
-      base::Bind(&SyncHttpBridgeTest::TestSameHttpNetworkSession,
-                 MessageLoop::current(), this));
-  MessageLoop::current()->Run();
+  io_thread()->message_loop()
+      ->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()));
   scoped_refptr<HttpBridge> http_bridge(new ShuntedHttpBridge(
       ctx_getter, this, false));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
@@ skipping 202 matching lines @@
   // succeed even though we Release()d the bridge above because the call to
   // Abort should have held a reference.
   io_waiter.Signal();
 
   // Done.
   sync_thread.Stop();
   io_thread()->Stop();
 }
 
 }  // namespace syncer