Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

components/navigation_interception/intercept_navigation_resource_throttle_unittest.cc

 // Copyright (c) 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "components/navigation_interception/intercept_navigation_resource_throttle.h"
 #include "components/navigation_interception/navigation_params.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/test/mock_resource_context.h"
-#include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_renderer_host.h"
 #include "net/url_request/url_request.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
 using testing::Property;
 using testing::Ne;
 using testing::Return;
 
 namespace navigation_interception {
 
 namespace {
 
 const char kTestUrl[] = "http://www.test.com/";
 const char kUnsafeTestUrl[] = "about:crash";
 
-void ContinueTestCase() {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE, base::MessageLoop::QuitClosure());
-}
-
 // The MS C++ compiler complains about not being able to resolve which url()
 // method (const or non-const) to use if we use the Property matcher to check
 // the return value of the NavigationParams::url() method.
 // It is possible to suppress the error by specifying the types directly but
 // that results in very ugly syntax, which is why these custom matchers are
 // used instead.
 MATCHER(NavigationParamsUrlIsTest, "") {
   return arg.url() == GURL(kTestUrl);
 }
 
@@ skipping 27 matching lines @@
   }
 
   Status status() const { return status_; }
 
   // ResourceController:
   virtual void Cancel() OVERRIDE {
     NOTREACHED();
   }
   virtual void CancelAndIgnore() OVERRIDE {
     status_ = CANCELLED;
-    ContinueTestCase();
   }
   virtual void CancelWithError(int error_code) OVERRIDE {
     NOTREACHED();
   }
   virtual void Resume() OVERRIDE {
     DCHECK(status_ == UNKNOWN);
     status_ = RESUMED;
-    ContinueTestCase();
   }
 
  private:
   Status status_;
 };
 
 // TestIOThreadState ----------------------------------------------------------
 
 class TestIOThreadState {
  public:
@@ skipping 42 matching lines @@
   MockResourceController throttle_controller_;
 };
 
 // InterceptNavigationResourceThrottleTest ------------------------------------
 
 class InterceptNavigationResourceThrottleTest
   : public content::RenderViewHostTestHarness {
  public:
   InterceptNavigationResourceThrottleTest()
       : mock_callback_receiver_(new MockInterceptCallbackReceiver()),
-        ui_thread_(content::BrowserThread::UI, &message_loop_),
-        io_thread_(content::BrowserThread::IO),
         io_thread_state_(NULL) {
   }
 
   virtual void SetUp() OVERRIDE {
     RenderViewHostTestHarness::SetUp();
-
-    io_thread_.StartIOThread();
   }
 
   virtual void TearDown() OVERRIDE {
     if (web_contents())
       web_contents()->SetDelegate(NULL);
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&base::DeletePointer<TestIOThreadState>, io_thread_state_));
@@ skipping 11 matching lines @@
       int render_process_id,
       int render_view_id,
       bool* defer) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
     TestIOThreadState* io_thread_state =
         new TestIOThreadState(url, render_process_id, render_view_id,
                               request_method, mock_callback_receiver_.get());
 
     SetIOThreadState(io_thread_state);
     io_thread_state->ThrottleWillStartRequest(defer);
-
-    if (!*defer) {
-      ContinueTestCase();
-    }
   }
 
  protected:
   enum ShouldIgnoreNavigationCallbackAction {
     IgnoreNavigation,
     DontIgnoreNavigation
   };
 
-  void SetUpWebContentsDelegateAndRunMessageLoop(
+  void SetUpWebContentsDelegateAndDrainRunLoop(
       ShouldIgnoreNavigationCallbackAction callback_action,
       bool* defer) {
 
     ON_CALL(*mock_callback_receiver_, ShouldIgnoreNavigation(_, _))
       .WillByDefault(Return(callback_action == IgnoreNavigation));
     EXPECT_CALL(*mock_callback_receiver_,
                 ShouldIgnoreNavigation(rvh(), NavigationParamsUrlIsTest()))
       .Times(1);
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             &InterceptNavigationResourceThrottleTest::
                 RunThrottleWillStartRequestOnIOThread,
             base::Unretained(this),
             GURL(kTestUrl),
             "GET",
             web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
             web_contents()->GetRenderViewHost()->GetRoutingID(),
             base::Unretained(defer)));
 
     // Wait for the request to finish processing.
-    message_loop_.Run();
+    base::RunLoop().RunUntilIdle();
   }
 
   void WaitForPreviouslyScheduledIoThreadWork() {
     base::WaitableEvent io_thread_work_done(true, false);
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(
           &base::WaitableEvent::Signal,
           base::Unretained(&io_thread_work_done)));
     io_thread_work_done.Wait();
   }
 
   scoped_ptr<MockInterceptCallbackReceiver> mock_callback_receiver_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread io_thread_;
   TestIOThreadState* io_thread_state_;
 };
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        RequestDeferredAndResumedIfNavigationNotIgnored) {
   bool defer = false;
-  SetUpWebContentsDelegateAndRunMessageLoop(DontIgnoreNavigation, &defer);
+  SetUpWebContentsDelegateAndDrainRunLoop(DontIgnoreNavigation, &defer);
 
   EXPECT_TRUE(defer);
   EXPECT_TRUE(io_thread_state_);
   EXPECT_TRUE(io_thread_state_->request_resumed());
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        RequestDeferredAndCancelledIfNavigationIgnored) {
   bool defer = false;
-  SetUpWebContentsDelegateAndRunMessageLoop(IgnoreNavigation, &defer);
+  SetUpWebContentsDelegateAndDrainRunLoop(IgnoreNavigation, &defer);
 
   EXPECT_TRUE(defer);
   EXPECT_TRUE(io_thread_state_);
   EXPECT_TRUE(io_thread_state_->request_cancelled());
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        NoCallbackMadeIfContentsDeletedWhileThrottleRunning) {
   bool defer = false;
 
   // The tested scenario is when the WebContents is deleted after the
   // ResourceThrottle has finished processing on the IO thread but before the
-  // UI thread callback has been processed.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(
-          &RenderViewHostTestHarness::DeleteContents,
-          base::Unretained(this)));
-
+  // UI thread callback has been processed.  Since both threads in this test
+  // are serviced by one message loop, the post order is the execution order.
   EXPECT_CALL(*mock_callback_receiver_,
               ShouldIgnoreNavigation(_, _))
       .Times(0);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &InterceptNavigationResourceThrottleTest::
           RunThrottleWillStartRequestOnIOThread,
           base::Unretained(this),
           GURL(kTestUrl),
           "GET",
           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           base::Unretained(&defer)));
 
-  WaitForPreviouslyScheduledIoThreadWork();
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &RenderViewHostTestHarness::DeleteContents,
+          base::Unretained(this)));
 
   // The WebContents will now be deleted and only after that will the UI-thread
   // callback posted by the ResourceThrottle be executed.
-  message_loop_.Run();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(defer);
   EXPECT_TRUE(io_thread_state_);
   EXPECT_TRUE(io_thread_state_->request_resumed());
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        RequestNotDeferredForRequestNotAssociatedWithARenderView) {
   bool defer = false;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &InterceptNavigationResourceThrottleTest::
               RunThrottleWillStartRequestOnIOThread,
           base::Unretained(this),
           GURL(kTestUrl),
           "GET",
           MSG_ROUTING_NONE,
           MSG_ROUTING_NONE,
           base::Unretained(&defer)));
 
   // Wait for the request to finish processing.
-  message_loop_.Run();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(defer);
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        CallbackCalledWithFilteredUrl) {
   bool defer = false;
 
   ON_CALL(*mock_callback_receiver_,
           ShouldIgnoreNavigation(_, NavigationParamsUrlIsSafe()))
       .WillByDefault(Return(false));
   EXPECT_CALL(*mock_callback_receiver_,
               ShouldIgnoreNavigation(_, NavigationParamsUrlIsSafe()))
       .Times(1);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &InterceptNavigationResourceThrottleTest::
               RunThrottleWillStartRequestOnIOThread,
           base::Unretained(this),
           GURL(kUnsafeTestUrl),
           "GET",
           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           base::Unretained(&defer)));
 
   // Wait for the request to finish processing.
-  message_loop_.Run();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        CallbackIsPostFalseForGet) {
   bool defer = false;
 
   EXPECT_CALL(*mock_callback_receiver_,
               ShouldIgnoreNavigation(_, AllOf(
                   NavigationParamsUrlIsSafe(),
                   Property(&NavigationParams::is_post, Eq(false)))))
       .WillOnce(Return(false));
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &InterceptNavigationResourceThrottleTest::
               RunThrottleWillStartRequestOnIOThread,
           base::Unretained(this),
           GURL(kTestUrl),
           "GET",
           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           base::Unretained(&defer)));
 
   // Wait for the request to finish processing.
-  message_loop_.Run();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(InterceptNavigationResourceThrottleTest,
        CallbackIsPostTrueForPost) {
   bool defer = false;
 
   EXPECT_CALL(*mock_callback_receiver_,
               ShouldIgnoreNavigation(_, AllOf(
                   NavigationParamsUrlIsSafe(),
                   Property(&NavigationParams::is_post, Eq(true)))))
       .WillOnce(Return(false));
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &InterceptNavigationResourceThrottleTest::
               RunThrottleWillStartRequestOnIOThread,
           base::Unretained(this),
           GURL(kTestUrl),
           "POST",
           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           base::Unretained(&defer)));
 
   // Wait for the request to finish processing.
-  message_loop_.Run();
+  base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace navigation_interception