Move initialization of ChromeURLRequestContexts to the IO thread.

chrome/browser/net/url_fetcher_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/thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/net/url_fetcher.h"
 #include "chrome/browser/net/url_fetcher_protect.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/ssl_test_util.h"
 #include "net/url_request/url_request_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 const wchar_t kDocRoot[] = L"chrome/test/data";
 
+class TestURLRequestContextGetter : public URLRequestContextGetter {
+ public:
+  virtual URLRequestContext* GetURLRequestContext() {
+    if (!context_)
+      context_ = new TestURLRequestContext();
+    return context_;
+  }
+ private:
+  scoped_refptr<URLRequestContext> context_;
+};
+
 class URLFetcherTest : public testing::Test, public URLFetcher::Delegate {
  public:
   URLFetcherTest() : fetcher_(NULL) { }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
   // URLFetcher::Delegate
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
@@ skipping 107 matching lines @@
   }
 
   virtual ~CancelTestURLRequestContext() {
     *destructor_called_ = true;
   }
 
  private:
   bool* destructor_called_;
 };
 
+class CancelTestURLRequestContextGetter : public URLRequestContextGetter {
+ public:
+  CancelTestURLRequestContextGetter(bool* destructor_called)
+      : destructor_called_(destructor_called) {
+  }
+
+  virtual URLRequestContext* GetURLRequestContext() {
+    if (!context_)
+      context_ = new CancelTestURLRequestContext(destructor_called_);
+    return context_;
+  }
+
+ private:
+  scoped_refptr<URLRequestContext> context_;
+  bool* destructor_called_;
+};
+
 // Wrapper that lets us call CreateFetcher() on a thread of our choice.  We
 // could make URLFetcherTest refcounted and use PostTask(FROM_HERE.. ) to call
 // CreateFetcher() directly, but the ownership of the URLFetcherTest is a bit
 // confusing in that case because GTest doesn't know about the refcounting.
 // It's less confusing to just do it this way.
 class FetcherWrapperTask : public Task {
  public:
   FetcherWrapperTask(URLFetcherTest* test, const GURL& url)
       : test_(test), url_(url) { }
   virtual void Run() {
     test_->CreateFetcher(url_);
   };
 
  private:
   URLFetcherTest* test_;
   GURL url_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContext());
+  fetcher_->set_request_context(new TestURLRequestContextGetter());
   fetcher_->set_io_loop(&io_loop_);
   fetcher_->Start();
 }
 
 void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source,
                                         const GURL& url,
                                         const URLRequestStatus& status,
                                         int response_code,
                                         const ResponseCookies& cookies,
                                         const std::string& data) {
   EXPECT_TRUE(status.is_success());
   EXPECT_EQ(200, response_code);  // HTTP OK
   EXPECT_FALSE(data.empty());
 
   delete fetcher_;  // Have to delete this here and not in the destructor,
                     // because the destructor won't necessarily run on the
                     // same thread that CreateFetcher() did.
 
   io_loop_.PostTask(FROM_HERE, new MessageLoop::QuitTask());
   // If MessageLoop::current() != io_loop_, it will be shut down when the
   // main loop returns and this thread subsequently goes out of scope.
 }
 
 void URLFetcherPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::POST, this);
-  fetcher_->set_request_context(new TestURLRequestContext());
+  fetcher_->set_request_context(new TestURLRequestContextGetter());
   fetcher_->set_io_loop(&io_loop_);
   fetcher_->set_upload_data("application/x-www-form-urlencoded",
                             "bobsyeruncle");
   fetcher_->Start();
 }
 
 void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source,
                                             const GURL& url,
                                             const URLRequestStatus& status,
                                             int response_code,
@@ skipping 14 matching lines @@
   std::string header;
   EXPECT_TRUE(source->response_headers()->GetNormalizedHeader("cache-control",
                                                               &header));
   EXPECT_EQ("private", header);
   URLFetcherTest::OnURLFetchComplete(source, url, status, response_code,
                                      cookies, data);
 }
 
 void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContext());
+  fetcher_->set_request_context(new TestURLRequestContextGetter());
   fetcher_->set_io_loop(&io_loop_);
   start_time_ = Time::Now();
   fetcher_->Start();
 }
 
 void URLFetcherProtectTest::OnURLFetchComplete(const URLFetcher* source,
                                                const GURL& url,
                                                const URLRequestStatus& status,
                                                int response_code,
                                                const ResponseCookies& cookies,
@@ skipping 51 matching lines @@
   EXPECT_TRUE(data.empty());
 
   // The rest is the same as URLFetcherTest::OnURLFetchComplete.
   delete fetcher_;
   io_loop_.Quit();
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
   fetcher_->set_request_context(
-      new CancelTestURLRequestContext(&context_released_));
+      new CancelTestURLRequestContextGetter(&context_released_));
   fetcher_->set_io_loop(&io_loop_);
   fetcher_->Start();
   // Make sure we give the IO thread a chance to run.
   timer_.Start(TimeDelta::FromMilliseconds(300), this,
                &URLFetcherCancelTest::CancelRequest);
 }
 
 void URLFetcherCancelTest::OnURLFetchComplete(const URLFetcher* source,
                                               const GURL& url,
                                               const URLRequestStatus& status,
@@ skipping 142 matching lines @@
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(FROM_HERE, new FetcherWrapperTask(this, url));
 
   MessageLoop::current()->Run();
 }
 
 }  // namespace.