VideoCapture: migrate last Renderer-->Host msg and start Host-->Renderer migration

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 82 matching lines @@
   MockVideoCaptureHost(MediaStreamManager* manager)
       : VideoCaptureHost(manager), return_buffers_immediately_(false) {}
 
   MOCK_METHOD4(OnNewBufferCreated,
                void(int device_id,
                     base::SharedMemoryHandle handle,
                     int length,
                     int buffer_id));
   MOCK_METHOD2(OnBufferFreed, void(int device_id, int buffer_id));
   MOCK_METHOD1(OnBufferFilled, void(int device_id));
-  MOCK_METHOD2(OnStateChanged, void(int device_id, VideoCaptureState state));
 
   void SetReturnReceivedBuffersImmediately(bool enable) {
     return_buffers_immediately_ = enable;
   }
 
   void ReturnReceivedBuffers(int device_id)  {
     while (!buffer_ids_.empty()) {
-      this->OnRendererFinishedWithBuffer(device_id, *buffer_ids_.begin(),
-                                         gpu::SyncToken(), -1.0);
+      this->ReleaseBuffer(device_id, *buffer_ids_.begin(), gpu::SyncToken(),
+                          -1.0);
       buffer_ids_.pop_front();
     }
   }
 
  private:
   ~MockVideoCaptureHost() override {}
 
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // some of these messages here to MOCK them and to map/unmap buffers.
   bool Send(IPC::Message* message) override {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureHost, *message)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnNewBufferCreatedDispatch)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_FreeBuffer, OnBufferFreedDispatch)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferFilledDispatch)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnStateChanged)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
   void OnNewBufferCreatedDispatch(int device_id,
@@ skipping 11 matching lines @@
     ASSERT_TRUE(buffer != buffer_ids_.end());
     buffer_ids_.erase(buffer);
   }
 
   void OnBufferFilledDispatch(
       const VideoCaptureMsg_BufferReady_Params& params) {
     OnBufferFilled(params.device_id);
     if (!return_buffers_immediately_)
       return;
 
-    VideoCaptureHost::OnRendererFinishedWithBuffer(
-        params.device_id, params.buffer_id, gpu::SyncToken(), -1.0);
+    VideoCaptureHost::ReleaseBuffer(params.device_id, params.buffer_id,
+                                    gpu::SyncToken(), -1.0);
   }
 
   std::list<int> buffer_ids_;
   bool return_buffers_immediately_;
 };
 
 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 {
+class VideoCaptureHostTest : public testing::Test,
+                             public mojom::VideoCaptureObserver {
  public:
   VideoCaptureHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        opened_session_id_(kInvalidMediaCaptureSessionId) {}
+        opened_session_id_(kInvalidMediaCaptureSessionId),
+        observer_binding_(this) {}
 
   void SetUp() override {
     SetBrowserClientForTesting(&browser_client_);
 
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::InitializeForTesting();
 #endif
 
     audio_manager_ = media::AudioManager::CreateForTesting(task_runner_);
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
@@ skipping 87 matching lines @@
 
   void CloseSession() {
     if (opened_device_label_.empty())
       return;
     media_stream_manager_->CancelRequest(opened_device_label_);
     opened_device_label_.clear();
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
+  MOCK_METHOD1(OnStateChanged, void(mojom::VideoCaptureState));
+
   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()));
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
-    host_->Start(kDeviceId, opened_session_id_, params);
+
+    EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STARTED));
+    host_->Start(kDeviceId, opened_session_id_, params,
+                 observer_binding_.CreateInterfacePtrAndBind());
+
     run_loop.Run();
   }
 
   void StartStopCapture() {
     // Quickly start and then stop capture, without giving much chance for
     // asynchronous start operations to complete.
     InSequence s;
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_.get(),
-                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED));
+
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
-    host_->Start(kDeviceId, opened_session_id_, params);
+
+    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(*host_.get(),
-                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_PAUSED));
+
+    EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::PAUSED));
     host_->Pause(kDeviceId);
 
-    EXPECT_CALL(*host_.get(),
-                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_RESUMED));
     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(*host_.get(),
-                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
+
+    EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STOPPED))
         .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
-
     host_->Stop(kDeviceId);
     host_->SetReturnReceivedBuffersImmediately(true);
     host_->ReturnReceivedBuffers(kDeviceId);
 
     run_loop.Run();
 
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_TRUE(host_->controllers_.empty());
   }
 
   void NotifyPacketReady() {
     base::RunLoop run_loop;
     EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()))
         .RetiresOnSaturation();
     run_loop.Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedBuffers(kDeviceId);
   }
 
   void SimulateError() {
     // Expect a change state to error state sent through IPC.
-    EXPECT_CALL(*host_.get(),
-                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ERROR)).Times(1);
+    EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::FAILED));
     VideoCaptureControllerID id(kDeviceId);
     host_->OnError(id);
     // Wait for the error callback.
     base::RunLoop().RunUntilIdle();
   }
 
   void WaitForVideoDeviceThread() {
     base::RunLoop run_loop;
     media_stream_manager_->video_capture_manager()->device_task_runner()
         ->PostTaskAndReply(
@@ skipping 13 matching lines @@
   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_;
 
+  mojo::Binding<mojom::VideoCaptureObserver> observer_binding_;
+
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
 TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
   StartCapture();
 
   // When the session is closed via the stream without stopping capture, the
   // ENDED event is sent.
-  EXPECT_CALL(*host_.get(),
-              OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ENDED)).Times(1);
+  EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::ENDED));
   CloseSession();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(VideoCaptureHostTest, StopWhileStartPending) {
   StartStopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCapturePlayStop) {
   StartCapture();
   NotifyPacketReady();
   NotifyPacketReady();
   ReturnReceivedPackets();
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureErrorStop) {
   StartCapture();
   SimulateError();
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureError) {
-  EXPECT_CALL(*host_.get(),
-              OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED)).Times(0);
+  EXPECT_CALL(*this, OnStateChanged(mojom::VideoCaptureState::STOPPED))
+      .Times(0);
   StartCapture();
   NotifyPacketReady();
   SimulateError();
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
 }
 
 TEST_F(VideoCaptureHostTest, PauseResumeCapture) {
   StartCapture();
   PauseResumeCapture();
   StopCapture();
 }
 
 }  // namespace content