Changed UrlFetcher to use a MessageLoopProxy instead of directly relying on C...

chrome/browser/sync/glue/http_bridge_unittest.cc

 // Copyright (c) 2006-2008 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/thread.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/net/test_url_fetcher_factory.h"
 #include "chrome/browser/sync/glue/http_bridge.h"
 #include "net/url_request/url_request_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using browser_sync::HttpBridge;
 
 namespace {
 // TODO(timsteele): Should use PathService here. See Chromium Issue 3113.
 const wchar_t kDocRoot[] = L"chrome/test/data";
 }
 
 // Lazy getter for TestURLRequestContext instances.
 class TestURLRequestContextGetter : public URLRequestContextGetter {
  public:
   virtual URLRequestContext* GetURLRequestContext() {
     if (!context_)
       context_ = new TestURLRequestContext;
     return context_;
   }
+  virtual scoped_refptr<MessageLoopProxy> GetIOMessageLoopProxy() {
+    return ChromeThread::GetMessageLoopProxyForThread(ChromeThread::IO);
+  }
+
  private:
   ~TestURLRequestContextGetter() {}
 
   scoped_refptr<URLRequestContext> context_;
 };
 
 class HttpBridgeTest : public testing::Test {
  public:
   HttpBridgeTest()
       : fake_default_request_context_getter_(NULL),
@@ skipping 17 matching lines @@
     if (!fake_default_request_context_getter_) {
       fake_default_request_context_getter_ = new TestURLRequestContextGetter();
       fake_default_request_context_getter_->AddRef();
     }
     HttpBridge* bridge = new HttpBridge(
         new HttpBridge::RequestContextGetter(
             fake_default_request_context_getter_));
     return bridge;
   }
 
+  static void TestSameHttpNetworkSession(MessageLoop* main_message_loop,
+                                         HttpBridgeTest* 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->GetRequestContextGetter()->
+                  GetURLRequestContext()->
+                  http_transaction_factory()->GetSession());
+    main_message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask);
+  }
+
   MessageLoop* io_thread_loop() { return io_thread_.message_loop(); }
 
   // Note this is lazy created, so don't call this before your bridge.
   TestURLRequestContextGetter* GetTestRequestContextGetter() {
     return fake_default_request_context_getter_;
   }
 
  private:
   // A make-believe "default" request context, as would be returned by
   // Profile::GetDefaultRequestContext().  Created lazily by BuildBridge.
   TestURLRequestContextGetter* fake_default_request_context_getter_;
 
   // Separate thread for IO used by the HttpBridge.
   ChromeThread io_thread_;
-
+  MessageLoop loop_;
 };
 
 class DummyURLFetcher : public TestURLFetcher {
  public:
   DummyURLFetcher() : TestURLFetcher(GURL(), POST, NULL) {}
 
   net::HttpResponseHeaders* response_headers() const {
     return NULL;
   }
 };
@@ skipping 25 matching lines @@
 
     std::string response_content = "success!";
     DummyURLFetcher fetcher;
     OnURLFetchComplete(&fetcher, GURL("www.google.com"), URLRequestStatus(),
                        200, cookies, response_content);
   }
   HttpBridgeTest* test_;
 };
 
 TEST_F(HttpBridgeTest, TestUsesSameHttpNetworkSession) {
-  scoped_refptr<HttpBridge> http_bridge(this->BuildBridge());
-  EXPECT_TRUE(GetTestRequestContextGetter());
-  net::HttpNetworkSession* test_session =
-      GetTestRequestContextGetter()->GetURLRequestContext()->
-      http_transaction_factory()->GetSession();
-  EXPECT_EQ(test_session,
-            http_bridge->GetRequestContextGetter()->
-                GetURLRequestContext()->
-                http_transaction_factory()->GetSession());
+  // Run this test on the IO thread because we can only call
+  // URLRequestContextGetter::GetURLRequestContext on the IO thread.
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableFunction(&HttpBridgeTest::TestSameHttpNetworkSession,
+                          MessageLoop::current(), this));
+  MessageLoop::current()->Run();
 }
 
 // Test the HttpBridge without actually making any network requests.
 TEST_F(HttpBridgeTest, TestMakeSynchronousPostShunted) {
   scoped_refptr<URLRequestContextGetter> ctx_getter(
       new TestURLRequestContextGetter());
   scoped_refptr<HttpBridge> http_bridge(new ShuntedHttpBridge(
       ctx_getter, this));
   http_bridge->SetUserAgent("bob");
   http_bridge->SetURL("http://www.google.com", 9999);
@@ skipping 111 matching lines @@
   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);
   EXPECT_EQ(0, os_error);
 
   EXPECT_EQ(http_bridge->GetResponseHeaderValue("Content-type"), "text/html");
   EXPECT_TRUE(http_bridge->GetResponseHeaderValue("invalid-header").empty());
 }