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

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/message_loop_proxy.h"
 #include "base/thread.h"
-#include "base/time.h"
-#include "base/timer.h"
+#include "base/waitable_event.h"
 #include "chrome/browser/chrome_thread.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;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 const wchar_t kDocRoot[] = L"chrome/test/data";
 
 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 URLFetcherTest : public testing::Test, public URLFetcher::Delegate {
  public:
   URLFetcherTest()
       : io_thread_(ChromeThread::IO, &io_loop_),
@@ skipping 108 matching lines @@
   virtual void CreateFetcher(const GURL& url);
   // URLFetcher::Delegate
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
   void CancelRequest();
-
- private:
-  base::OneShotTimer<URLFetcherCancelTest> timer_;
 };
 
 // Version of TestURLRequestContext that posts a Quit task to the IO
 // thread once it is deleted.
 class CancelTestURLRequestContext : public TestURLRequestContext {
   virtual ~CancelTestURLRequestContext() {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE, new MessageLoop::QuitTask());
   }
 };
 
 class CancelTestURLRequestContextGetter : public URLRequestContextGetter {
  public:
+  CancelTestURLRequestContextGetter() : context_created_(false, false) {
+  }
   virtual URLRequestContext* GetURLRequestContext() {
-    if (!context_)
+    if (!context_) {
       context_ = new CancelTestURLRequestContext();
+      context_created_.Signal();
+    }
     return context_;
   }
+  virtual scoped_refptr<MessageLoopProxy> GetIOMessageLoopProxy() {
+    return ChromeThread::GetMessageLoopProxyForThread(ChromeThread::IO);
+  }
+  void WaitForContextCreation() {
+    context_created_.Wait();
+  }
 
  private:
   ~CancelTestURLRequestContextGetter() {}
 
+  base::WaitableEvent context_created_;
   scoped_refptr<URLRequestContext> context_;
 };
 
 // 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:
@@ skipping 170 matching lines @@
   EXPECT_TRUE(data.empty());
 
   // The rest is the same as URLFetcherTest::OnURLFetchComplete.
   delete fetcher_;
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE, new MessageLoop::QuitTask());
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  // We need to force the creation of the URLRequestContext, since we
-  // rely on it being destroyed as a signal to end the test.
-  URLRequestContextGetter* context_getter =
-      new CancelTestURLRequestContextGetter();
-  context_getter->GetURLRequestContext();
+  CancelTestURLRequestContextGetter* context_getter =
+      new CancelTestURLRequestContextGetter;
   fetcher_->set_request_context(context_getter);
   fetcher_->Start();
-  // Make sure we give the IO thread a chance to run.
-  timer_.Start(TimeDelta::FromMilliseconds(300), this,
-               &URLFetcherCancelTest::CancelRequest);
+  // We need to wait for the creation of the URLRequestContext, since we
+  // rely on it being destroyed as a signal to end the test.
+  context_getter->WaitForContextCreation();
+  CancelRequest();
 }
 
 void URLFetcherCancelTest::OnURLFetchComplete(const URLFetcher* source,
                                               const GURL& url,
                                               const URLRequestStatus& status,
                                               int response_code,
                                               const ResponseCookies& cookies,
                                               const std::string& data) {
   // We should have cancelled the request before completion.
   ADD_FAILURE();
   delete fetcher_;
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE, new MessageLoop::QuitTask());
 }
 
 void URLFetcherCancelTest::CancelRequest() {
   delete fetcher_;
-  timer_.Stop();
   // The URLFetcher's test context will post a Quit task once it is
   // deleted. So if this test simply hangs, it means cancellation
   // did not work.
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   scoped_refptr<HTTPTestServer> server =
@@ skipping 166 matching lines @@
   // time difference from now).
 
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(FROM_HERE, new FetcherWrapperTask(this, url));
 
   MessageLoop::current()->Run();
 }
 
 }  // namespace.