Revert "content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs"

content/browser/renderer_host/media/video_capture_host_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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
-#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_host.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/video_capture_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_context.h"
@@ skipping 238 matching lines @@
     OnStateChanged(device_id, state);
   }
 
   std::map<int, base::SharedMemory*> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
   media::VideoCaptureFormat format_;
   DumpVideo dumper_;
 };
 
-ACTION_P2(ExitMessageLoop, task_runner, quit_closure) {
-  task_runner->PostTask(FROM_HERE, quit_closure);
+ACTION_P2(ExitMessageLoop, message_loop, quit_closure) {
+  message_loop->PostTask(FROM_HERE, quit_closure);
 }
 
 // This is an integration test of VideoCaptureHost in conjunction with
 // MediaStreamManager, VideoCaptureManager, VideoCaptureController, and
 // VideoCaptureDevice.
 class VideoCaptureHostTest : public testing::Test {
  public:
   VideoCaptureHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        task_runner_(base::ThreadTaskRunnerHandle::Get()),
+        message_loop_(base::MessageLoopProxy::current()),
         opened_session_id_(kInvalidMediaCaptureSessionId) {}
 
   void SetUp() override {
     SetBrowserClientForTesting(&browser_client_);
 
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::InitializeForTesting();
 #endif
 
     // Create our own MediaStreamManager.
@@ skipping 45 matching lines @@
     {
       base::RunLoop run_loop;
       std::string label = media_stream_manager_->EnumerateDevices(
           &stream_requester_,
           render_process_id,
           render_frame_id,
           browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
           page_request_id,
           MEDIA_DEVICE_VIDEO_CAPTURE,
           security_origin);
-      EXPECT_CALL(stream_requester_,
-                  DevicesEnumerated(render_frame_id, page_request_id, label, _))
-          .Times(1)
-          .WillOnce(DoAll(ExitMessageLoop(task_runner_, run_loop.QuitClosure()),
-                          SaveArg<3>(&devices)));
+      EXPECT_CALL(stream_requester_, DevicesEnumerated(render_frame_id,
+                                                       page_request_id,
+                                                       label,
+                                                       _))
+          .Times(1).WillOnce(
+              DoAll(ExitMessageLoop(message_loop_, run_loop.QuitClosure()),
+                    SaveArg<3>(&devices)));
       run_loop.Run();
       Mock::VerifyAndClearExpectations(&stream_requester_);
       media_stream_manager_->CancelRequest(label);
     }
     ASSERT_FALSE(devices.empty());
     ASSERT_EQ(StreamDeviceInfo::kNoId, devices[0].session_id);
 
     // Open the first device.
     {
       base::RunLoop run_loop;
       StreamDeviceInfo opened_device;
       media_stream_manager_->OpenDevice(
           &stream_requester_,
           render_process_id,
           render_frame_id,
           browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
           page_request_id,
           devices[0].device.id,
           MEDIA_DEVICE_VIDEO_CAPTURE,
           security_origin);
-      EXPECT_CALL(stream_requester_,
-                  DeviceOpened(render_frame_id, page_request_id, _, _))
-          .Times(1)
-          .WillOnce(DoAll(ExitMessageLoop(task_runner_, run_loop.QuitClosure()),
-                          SaveArg<2>(&opened_device_label_),
-                          SaveArg<3>(&opened_device)));
+      EXPECT_CALL(stream_requester_, DeviceOpened(render_frame_id,
+                                                  page_request_id,
+                                                  _,
+                                                  _))
+          .Times(1).WillOnce(
+              DoAll(ExitMessageLoop(message_loop_, run_loop.QuitClosure()),
+                    SaveArg<2>(&opened_device_label_),
+                    SaveArg<3>(&opened_device)));
       run_loop.Run();
       Mock::VerifyAndClearExpectations(&stream_requester_);
       ASSERT_NE(StreamDeviceInfo::kNoId, opened_device.session_id);
       opened_session_id_ = opened_device.session_id;
     }
   }
 
   void CloseSession() {
     if (opened_device_label_.empty())
       return;
     media_stream_manager_->CancelRequest(opened_device_label_);
     opened_device_label_.clear();
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
   void StartCapture() {
     EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return());
 
     base::RunLoop run_loop;
     EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _, _))
         .Times(AnyNumber())
-        .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
+        .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 
   void StartStopCapture() {
     // Quickly start and then stop capture, without giving much chance for
@@ skipping 28 matching lines @@
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 #endif
 
   void StopCapture() {
     base::RunLoop run_loop;
     EXPECT_CALL(*host_.get(),
                 OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
-        .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
+        .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     host_->OnStopCapture(kDeviceId);
     host_->SetReturnReceivedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     run_loop.Run();
 
     host_->SetReturnReceivedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
     base::RunLoop run_loop;
     EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _, _))
         .Times(AnyNumber())
-        .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()))
+        .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()))
         .RetiresOnSaturation();
     run_loop.Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedDibs(kDeviceId);
   }
 
   void SimulateError() {
     // Expect a change state to error state sent through IPC.
@@ skipping 17 matching lines @@
 
   scoped_refptr<MockVideoCaptureHost> host_;
 
  private:
   StrictMock<MockMediaStreamRequester> stream_requester_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   content::TestBrowserContext browser_context_;
   content::TestContentBrowserClient browser_client_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
   int opened_session_id_;
   std::string opened_device_label_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
 TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
   StartCapture();
 
   // When the session is closed via the stream without stopping capture, the
@@ skipping 34 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content