content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/renderer_host/render_widget_host_view_browsertest.cc

 // Copyright (c) 2013 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/barrier_closure.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_paths.h"
@@ skipping 102 matching lines @@
   void FinishCopyFromCompositingSurface(const base::Closure& quit_closure,
                                         bool frame_captured) {
     ++callback_invoke_count_;
     if (frame_captured)
       ++frames_captured_;
     if (!quit_closure.is_null())
       quit_closure.Run();
   }
 
   // Callback when using frame subscriber API.
-  void FrameDelivered(const scoped_refptr<base::MessageLoopProxy>& loop,
-                      base::Closure quit_closure,
-                      base::TimeTicks timestamp,
-                      bool frame_captured) {
+  void FrameDelivered(
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      base::Closure quit_closure,
+      base::TimeTicks timestamp,
+      bool frame_captured) {
     ++callback_invoke_count_;
     if (frame_captured)
       ++frames_captured_;
     if (!quit_closure.is_null())
-      loop->PostTask(FROM_HERE, quit_closure);
+      task_runner->PostTask(FROM_HERE, quit_closure);
   }
 
   // Copy one frame using the CopyFromBackingStore API.
   void RunBasicCopyFromBackingStoreTest() {
     SET_UP_SURFACE_OR_PASS_TEST(NULL);
 
     // Repeatedly call CopyFromBackingStore() since, on some platforms (e.g.,
     // Windows), the operation will fail until the first "present" has been
     // made.
     int count_attempts = 0;
@@ skipping 24 matching lines @@
   // Waits until the source is available for copying.
   void WaitForCopySourceReady() {
     while (!GetRenderWidgetHostView()->IsSurfaceAvailableForCopy())
       GiveItSomeTime();
   }
 
   // Run the current message loop for a short time without unwinding the current
   // call stack.
   static void GiveItSomeTime() {
     base::RunLoop run_loop;
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        run_loop.QuitClosure(),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(10));
     run_loop.Run();
   }
 
  private:
   const gfx::Size frame_size_;
   base::FilePath test_dir_;
   int callback_invoke_count_;
   int frames_captured_;
 };
@@ skipping 134 matching lines @@
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewBase* const view = GetRenderWidgetHostView();
   if (!view->CanSubscribeFrame()) {
     LOG(WARNING) << ("Blindly passing this test: Frame subscription not "
                      "supported on this platform.");
     return;
   }
 
   base::RunLoop run_loop;
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
-      new FakeFrameSubscriber(
-          base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
-                     base::Unretained(this),
-                     base::MessageLoopProxy::current(),
-                     run_loop.QuitClosure())));
+      new FakeFrameSubscriber(base::Bind(
+          &RenderWidgetHostViewBrowserTest::FrameDelivered,
+          base::Unretained(this), base::ThreadTaskRunnerHandle::Get(),
+          run_loop.QuitClosure())));
   view->BeginFrameSubscription(subscriber.Pass());
   run_loop.Run();
   view->EndFrameSubscription();
 
   EXPECT_LE(1, callback_invoke_count());
   EXPECT_LE(1, frames_captured());
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewBase* const view = GetRenderWidgetHostView();
   if (!view->CanCopyToVideoFrame()) {
     LOG(WARNING) << ("Blindly passing this test: "
                      "CopyFromCompositingSurfaceToVideoFrame() not supported "
                      "on this platform.");
     return;
   }
 
   base::RunLoop run_loop;
   scoped_refptr<media::VideoFrame> first_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(first_output.get());
   scoped_refptr<media::VideoFrame> second_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(second_output.get());
   base::Closure closure = base::BarrierClosure(2, run_loop.QuitClosure());
   view->CopyFromCompositingSurfaceToVideoFrame(
       gfx::Rect(view->GetViewBounds().size()), first_output,
       base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
-                 base::Unretained(this), base::MessageLoopProxy::current(),
+                 base::Unretained(this), base::ThreadTaskRunnerHandle::Get(),
                  closure, base::TimeTicks::Now()));
   view->CopyFromCompositingSurfaceToVideoFrame(
       gfx::Rect(view->GetViewBounds().size()), second_output,
       base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
-                 base::Unretained(this), base::MessageLoopProxy::current(),
+                 base::Unretained(this), base::ThreadTaskRunnerHandle::Get(),
                  closure, base::TimeTicks::Now()));
   run_loop.Run();
 
   EXPECT_EQ(2, callback_invoke_count());
   EXPECT_EQ(2, frames_captured());
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCapture
     : public CompositingRenderWidgetHostViewBrowserTest {
  public:
@@ skipping 564 matching lines @@
                         kTestCompositingModes);
 INSTANTIATE_TEST_CASE_P(
     GLAndSoftwareCompositing,
     CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI,
     kTestCompositingModes);
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 }  // namespace
 }  // namespace content