VideoCapture: more migration IPC-->mojo, part 6

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 "content/browser/renderer_host/media/video_capture_host.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 66 matching lines @@
   MOCK_METHOD4(DeviceOpened, void(int render_frame_id,
                                   int page_request_id,
                                   const std::string& label,
                                   const StreamDeviceInfo& device_info));
   MOCK_METHOD1(DevicesChanged, void(MediaStreamType type));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMediaStreamRequester);
 };
 
-class MockVideoCaptureHost : public VideoCaptureHost {
- public:
-  MockVideoCaptureHost(MediaStreamManager* manager)
-      : VideoCaptureHost(manager) {}
-
-  MOCK_METHOD4(OnNewBufferCreated,
-               void(int device_id,
-                    base::SharedMemoryHandle handle,
-                    int length,
-                    int buffer_id));
-
- private:
-  ~MockVideoCaptureHost() override {}
-
-  bool Send(IPC::Message* message) override {
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureHost, *message)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnNewBufferCreated)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    EXPECT_TRUE(handled);
-
-    delete message;
-    return true;
-  }
-};
-
 ACTION_P2(ExitMessageLoop, task_runner, quit_closure) {
   task_runner->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 mojom::VideoCaptureObserver {
  public:
   VideoCaptureHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         audio_manager_(
             new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get())),
         task_runner_(base::ThreadTaskRunnerHandle::Get()),
         opened_session_id_(kInvalidMediaCaptureSessionId),
         observer_binding_(this) {}
 
   void SetUp() override {
     SetBrowserClientForTesting(&browser_client_);
 
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeUIForMediaStream);
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
 
     // Create a Host and connect it to a simulated IPC channel.
-    host_ = new MockVideoCaptureHost(media_stream_manager_.get());
+    host_ = new VideoCaptureHost(media_stream_manager_.get());
     host_->OnChannelConnected(base::GetCurrentProcId());
 
     OpenSession();
   }
 
   void TearDown() override {
     Mock::VerifyAndClearExpectations(host_.get());
     EXPECT_TRUE(host_->controllers_.empty());
 
     CloseSession();
@@ skipping 68 matching lines @@
     if (opened_device_label_.empty())
       return;
     media_stream_manager_->CancelRequest(opened_device_label_);
     opened_device_label_.clear();
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
   // mojom::VideoCaptureObserver implementation.
   MOCK_METHOD1(OnStateChanged, void(mojom::VideoCaptureState));
+  void OnBufferCreated(int32_t buffer_id,
+                       mojo::ScopedSharedBufferHandle handle) override {
+    DoOnBufferCreated(buffer_id);
+  }
+  MOCK_METHOD1(DoOnBufferCreated, void(int32_t));
   void OnBufferReady(int32_t buffer_id,
                      mojom::VideoFrameInfoPtr info) override {
     DoOnBufferReady(buffer_id);
   }
   MOCK_METHOD1(DoOnBufferReady, void(int32_t));
   MOCK_METHOD1(OnBufferDestroyed, void(int32_t));
 
   void StartCapture() {
     base::RunLoop run_loop;
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STARTED));
-    EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
+    EXPECT_CALL(*this, DoOnBufferCreated(_))
         .Times(AnyNumber())
         .WillRepeatedly(Return());
     EXPECT_CALL(*this, DoOnBufferReady(_))
         .Times(AnyNumber())
-        .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
+        .WillRepeatedly(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
 
     host_->Start(kDeviceId, opened_session_id_, params,
                  observer_binding_.CreateInterfacePtrAndBind());
 
     run_loop.Run();
   }
 
-  void StartStopCapture() {
+  void StartAndImmediateStopCapture() {
     // Quickly start and then stop capture, without giving much chance for
     // asynchronous capture operations to produce frames.
     InSequence s;
     base::RunLoop run_loop;
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STARTED));
     host_->Start(kDeviceId, opened_session_id_, params,
                  observer_binding_.CreateInterfacePtrAndBind());
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STOPPED));
     host_->Stop(kDeviceId);
     run_loop.RunUntilIdle();
-    WaitForVideoDeviceThread();
   }
 
   void PauseResumeCapture() {
     InSequence s;
     base::RunLoop run_loop;
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::PAUSED));
     host_->Pause(kDeviceId);
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::RESUMED));
     host_->Resume(kDeviceId, opened_session_id_, params);
     run_loop.RunUntilIdle();
-    WaitForVideoDeviceThread();
   }
 
   void StopCapture() {
     base::RunLoop run_loop;
 
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STOPPED))
         .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
     host_->Stop(kDeviceId);
 
     run_loop.Run();
@@ skipping 11 matching lines @@
     run_loop.Run();
   }
 
   void SimulateError() {
     EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::FAILED));
     VideoCaptureControllerID id(kDeviceId);
     host_->OnError(id);
     base::RunLoop().RunUntilIdle();
   }
 
-  void WaitForVideoDeviceThread() {
-    base::RunLoop run_loop;
-    media_stream_manager_->video_capture_manager()->device_task_runner()
-        ->PostTaskAndReply(
-            FROM_HERE,
-            base::Bind(&base::DoNothing),
-            run_loop.QuitClosure());
-    run_loop.Run();
-  }
-
-  scoped_refptr<MockVideoCaptureHost> host_;
-
  private:
   // |media_stream_manager_| needs to outlive |thread_bundle_| because it is a
   // MessageLoop::DestructionObserver.
   StrictMock<MockMediaStreamRequester> stream_requester_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   const content::TestBrowserThreadBundle thread_bundle_;
   // |audio_manager_| needs to outlive |thread_bundle_| because it uses the
   // underlying message loop.
   media::ScopedAudioManagerPtr audio_manager_;
   content::TestBrowserContext browser_context_;
   content::TestContentBrowserClient browser_client_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   int opened_session_id_;
   std::string opened_device_label_;
 
+  scoped_refptr<VideoCaptureHost> host_;
   mojo::Binding<mojom::VideoCaptureObserver> observer_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
-TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
-  StartCapture();
+// Construct and destruct all objects. This is a non trivial sequence.
+TEST_F(VideoCaptureHostTest, ConstructAndDestruct) {}
 
-  // When the session is closed via the stream without stopping capture, the
-  // ENDED event is sent.
-  EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::ENDED));
-  CloseSession();
-  base::RunLoop().RunUntilIdle();
+TEST_F(VideoCaptureHostTest, StartAndImmediateStop) {
+  StartAndImmediateStopCapture();
 }
 
-TEST_F(VideoCaptureHostTest, StopWhileStartPending) {
-  StartStopCapture();
-}
-
-TEST_F(VideoCaptureHostTest, StartCapturePlayStop) {
+TEST_F(VideoCaptureHostTest, StartAndCaptureAndStop) {
   StartCapture();
   WaitForOneCapturedBuffer();
   WaitForOneCapturedBuffer();
   StopCapture();
 }
 
-TEST_F(VideoCaptureHostTest, StartCaptureErrorStop) {
+TEST_F(VideoCaptureHostTest, StartAndErrorAndStop) {
   StartCapture();
   SimulateError();
   StopCapture();
 }
 
-TEST_F(VideoCaptureHostTest, StartCaptureError) {
+TEST_F(VideoCaptureHostTest, StartAndCaptureAndError) {
   EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STOPPED))
       .Times(0);
   StartCapture();
   WaitForOneCapturedBuffer();
   SimulateError();
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
 }
 
-TEST_F(VideoCaptureHostTest, PauseResumeCapture) {
+TEST_F(VideoCaptureHostTest, StartAndPauseAndResumeAndStop) {
   StartCapture();
   PauseResumeCapture();
   StopCapture();
 }
 
+TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
+  StartCapture();
+
+  // When the session is closed via the stream without stopping capture, the
+  // ENDED event is sent.
+  EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::ENDED));
+  CloseSession();
+  base::RunLoop().RunUntilIdle();
+}
+
 }  // namespace content