Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

content/browser/renderer_host/media/web_contents_video_capture_device_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 "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_oracle.h"
 #include "content/browser/renderer_host/media/web_contents_capture_util.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_web_contents.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace content {
@@ skipping 374 matching lines @@
   bool error_encountered_;
   SkColor wait_color_yuv_;
   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(StubConsumer);
 };
 
 // Test harness that sets up a minimal environment with necessary stubs.
 class WebContentsVideoCaptureDeviceTest : public testing::Test {
  public:
-  WebContentsVideoCaptureDeviceTest() {}
-
+  // This is public because C++ method pointer scoping rules are silly and make
+  // this hard to use with Bind().
   void ResetWebContents() {
     web_contents_.reset();
   }
 
  protected:
   virtual void SetUp() {
     // TODO(nick): Sadness and woe! Much "mock-the-world" boilerplate could be
     // eliminated here, if only we could use RenderViewHostTestHarness. The
     // catch is that we need our TestRenderViewHost to support a
     // CopyFromBackingStore operation that we control. To accomplish that,
     // either RenderViewHostTestHarness would have to support installing a
     // custom RenderViewHostFactory, or else we implant some kind of delegated
     // CopyFromBackingStore functionality into TestRenderViewHost itself.
 
-    // The main thread will serve as the UI thread as well as the test thread.
-    // We'll manually pump the run loop at appropriate times in the test.
-    ui_thread_.reset(new TestBrowserThread(BrowserThread::UI, &message_loop_));
-
     render_process_host_factory_.reset(new MockRenderProcessHostFactory());
     // Create our (self-registering) RVH factory, so that when we create a
     // WebContents, it in turn creates CaptureTestRenderViewHosts.
     render_view_host_factory_.reset(
         new CaptureTestRenderViewHostFactory(&controller_));
 
     browser_context_.reset(new TestBrowserContext());
 
     scoped_refptr<SiteInstance> site_instance =
         SiteInstance::Create(browser_context_.get());
     SiteInstanceImpl::set_render_process_host_factory(
         render_process_host_factory_.get());
     web_contents_.reset(
         TestWebContents::Create(browser_context_.get(), site_instance.get()));
 
     // This is actually a CaptureTestRenderViewHost.
     RenderWidgetHostImpl* rwh =
         RenderWidgetHostImpl::From(web_contents_->GetRenderViewHost());
 
     std::string device_id =
         WebContentsCaptureUtil::AppendWebContentsDeviceScheme(
             base::StringPrintf("%d:%d", rwh->GetProcess()->GetID(),
                                rwh->GetRoutingID()));
 
     device_.reset(WebContentsVideoCaptureDevice::Create(device_id));
 
-    content::RunAllPendingInMessageLoop();
+    base::RunLoop().RunUntilIdle();
   }
 
   virtual void TearDown() {
     // Tear down in opposite order of set-up.
 
     // The device is destroyed asynchronously, and will notify the
     // CaptureTestSourceController when it finishes destruction.
     // Trigger this, and wait.
     if (device_) {
       device_->DeAllocate();
       device_.reset();
     }
 
-    content::RunAllPendingInMessageLoop();
+    base::RunLoop().RunUntilIdle();
 
     // Destroy the browser objects.
     web_contents_.reset();
     browser_context_.reset();
 
-    content::RunAllPendingInMessageLoop();
+    base::RunLoop().RunUntilIdle();
 
     SiteInstanceImpl::set_render_process_host_factory(NULL);
     render_view_host_factory_.reset();
     render_process_host_factory_.reset();
   }
 
   // Accessors.
   CaptureTestSourceController* source() { return &controller_; }
   media::VideoCaptureDevice* device() { return device_.get(); }
   StubConsumer* consumer() { return &consumer_; }
@@ skipping 15 matching lines @@
 
   void DestroyVideoCaptureDevice() { device_.reset(); }
 
  private:
   // The consumer is the ultimate recipient of captured pixel data.
   StubConsumer consumer_;
 
   // The controller controls which pixel patterns to produce.
   CaptureTestSourceController controller_;
 
-  // We run the UI message loop on the main thread. The capture device
-  // will also spin up its own threads.
-  base::MessageLoopForUI message_loop_;
-  scoped_ptr<TestBrowserThread> ui_thread_;
-
   // Self-registering RenderProcessHostFactory.
   scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory_;
 
   // Creates capture-capable RenderViewHosts whose pixel content production is
   // under the control of |controller_|.
   scoped_ptr<CaptureTestRenderViewHostFactory> render_view_host_factory_;
 
   // A mocked-out browser and tab.
   scoped_ptr<TestBrowserContext> browser_context_;
   scoped_ptr<WebContents> web_contents_;
 
   // Finally, the WebContentsVideoCaptureDevice under test.
   scoped_ptr<media::VideoCaptureDevice> device_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebContentsVideoCaptureDeviceTest);
+  TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(WebContentsVideoCaptureDeviceTest, InvalidInitialWebContentsError) {
   // Before the installs itself on the UI thread up to start capturing, we'll
   // delete the web contents. This should trigger an error which can happen in
   // practice; we should be able to recover gracefully.
   ResetWebContents();
 
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond, consumer());
   device()->Start();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForError());
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, WebContentsDestroyed) {
   // We'll simulate the tab being closed after the capture pipeline is up and
   // running.
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond, consumer());
   device()->Start();
 
   // Do one capture to prove
   source()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
 
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop().RunUntilIdle();
 
   // Post a task to close the tab. We should see an error reported to the
   // consumer.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&WebContentsVideoCaptureDeviceTest::ResetWebContents,
                  base::Unretained(this)));
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForError());
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest,
        StopDeviceBeforeCaptureMachineCreation) {
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond, consumer());
   device()->Start();
   // Make a point of not running the UI messageloop here.
   device()->Stop();
   device()->DeAllocate();
   DestroyVideoCaptureDevice();
 
   // Currently, there should be CreateCaptureMachineOnUIThread() and
   // DestroyCaptureMachineOnUIThread() tasks pending on the current (UI) message
   // loop. These should both succeed without crashing, and the machine should
   // wind up in the idle state.
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, StopWithRendererWorkToDo) {
   // Set up the test to use RGB copies and an normal
   source()->SetCanCopyToVideoFrame(false);
   source()->SetUseFrameSubscriber(false);
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond,
                      consumer());
   device()->Start();
   // Make a point of not running the UI messageloop here.
-  content::RunAllPendingInMessageLoop();
+  // TODO(ajwong): Why do we care?
+  base::RunLoop().RunUntilIdle();
 
   for (int i = 0; i < 10; ++i)
     SimulateDrawEvent();
 
   device()->Stop();
   device()->DeAllocate();
   // Currently, there should be CreateCaptureMachineOnUIThread() and
   // DestroyCaptureMachineOnUIThread() tasks pending on the current message
   // loop. These should both succeed without crashing, and the machine should
   // wind up in the idle state.
   ASSERT_FALSE(consumer()->HasError());
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(consumer()->HasError());
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, DeviceRestart) {
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond, consumer());
   device()->Start();
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop().RunUntilIdle();
   source()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
   SimulateDrawEvent();
   SimulateDrawEvent();
   source()->SetSolidColor(SK_ColorGREEN);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorGREEN));
   device()->Stop();
 
   // Device is stopped, but content can still be animating.
   SimulateDrawEvent();
   SimulateDrawEvent();
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop().RunUntilIdle();
 
   device()->Start();
   source()->SetSolidColor(SK_ColorBLUE);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorBLUE));
   source()->SetSolidColor(SK_ColorYELLOW);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorYELLOW));
   device()->DeAllocate();
 }
@@ skipping 79 matching lines @@
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
 
   device()->Stop();
   device()->DeAllocate();
 }
 
 }  // namespace
 }  // namespace content