VideoCapture: moar VideoCapture renderer-->host messages to mojo, part 3

content/renderer/media/video_capture_impl_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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 #include "content/common/video_capture.mojom.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
+using ::testing::Invoke;
 using ::testing::SaveArg;
+using ::testing::WithArgs;
 
 namespace content {
 
 const int kSessionId = 1;
 
+void RunEmptyFormatsCallback(const VideoCaptureDeviceFormatsCB& callback) {
+  media::VideoCaptureFormats formats;
+  callback.Run(formats);
+}
+
 // Mock implementation of the Mojo service. TODO(mcasas): Replace completely
 // MockVideoCaptureMessageFilter, https://crbug.com/651897
 class MockMojoVideoCaptureHost : public mojom::VideoCaptureHost {
  public:
-  MockMojoVideoCaptureHost() = default;
+  MockMojoVideoCaptureHost() {
+    ON_CALL(*this, GetDeviceSupportedFormats(_, _, _))
+        .WillByDefault(WithArgs<2>(Invoke(RunEmptyFormatsCallback)));
+    ON_CALL(*this, GetDeviceFormatsInUse(_, _, _))
+        .WillByDefault(WithArgs<2>(Invoke(RunEmptyFormatsCallback)));
+  }
 
   MOCK_METHOD3(Start, void(int32_t, int32_t, const media::VideoCaptureParams&));
   MOCK_METHOD1(Stop, void(int32_t));
   MOCK_METHOD1(Pause, void(int32_t));
   MOCK_METHOD3(Resume,
                void(int32_t, int32_t, const media::VideoCaptureParams&));
   MOCK_METHOD1(RequestRefreshFrame, void(int32_t));
+  MOCK_METHOD3(GetDeviceSupportedFormats,
+               void(int32_t,
+                    int32_t,
+                    const GetDeviceSupportedFormatsCallback&));
+  MOCK_METHOD3(GetDeviceFormatsInUse,
+               void(int32_t, int32_t, const GetDeviceFormatsInUseCallback&));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMojoVideoCaptureHost);
 };
 
 class MockVideoCaptureMessageFilter : public VideoCaptureMessageFilter {
  public:
   MockVideoCaptureMessageFilter() : VideoCaptureMessageFilter() {}
 
   // Filter implementation.
@@ skipping 14 matching lines @@
                          VideoCaptureMessageFilter* filter)
         : VideoCaptureImpl(id, filter, base::ThreadTaskRunnerHandle::Get()),
           received_buffer_count_(0) {}
     ~MockVideoCaptureImpl() override {}
 
     void Send(IPC::Message* message) override {
       bool handled = true;
       IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureImpl, *message)
         IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_BufferReady,
                             DeviceReceiveEmptyBuffer)
-        IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_GetDeviceSupportedFormats,
-                            DeviceGetSupportedFormats)
-        IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_GetDeviceFormatsInUse,
-                            DeviceGetFormatsInUse)
         IPC_MESSAGE_UNHANDLED(handled = false)
       IPC_END_MESSAGE_MAP()
       EXPECT_TRUE(handled);
       delete message;
     }
 
     void DeviceReceiveEmptyBuffer(int device_id,
                                   int buffer_id,
                                   const gpu::SyncToken& release_sync_token,
                                   double consumer_resource_utilization) {
       received_buffer_count_++;
     }
 
-    void DeviceGetSupportedFormats(int device_id,
-                                   media::VideoCaptureSessionId session_id) {
-      // When the mock message filter receives a request for the device
-      // supported formats, replies immediately with an empty format list.
-      OnDeviceSupportedFormatsEnumerated(media::VideoCaptureFormats());
-    }
-
-    void DeviceGetFormatsInUse(int device_id,
-                               media::VideoCaptureSessionId session_id) {
-      OnDeviceFormatsInUseReceived(media::VideoCaptureFormats());
-    }
-
     void ReceiveStateChangeMessage(VideoCaptureState state) {
       OnStateChanged(state);
     }
 
     int received_buffer_count() const { return received_buffer_count_; }
 
    private:
     int received_buffer_count_;
   };
 
@@ skipping 127 matching lines @@
   StartCapture(0, params_small_);
   StopCapture(0);
   StartCapture(1, params_large_);
   StopCapture(1);
 }
 
 // Checks that a request to GetDeviceSupportedFormats() ends up eventually in
 // the provided callback.
 TEST_F(VideoCaptureImplTest, GetDeviceFormats) {
   EXPECT_CALL(*this, OnDeviceSupportedFormats(_));
+  EXPECT_CALL(mock_video_capture_host_,
+              GetDeviceSupportedFormats(_, kSessionId, _));
 
   GetDeviceSupportedFormats();
 }
 
 // Checks that two requests to GetDeviceSupportedFormats() end up eventually
 // calling the provided callbacks.
 TEST_F(VideoCaptureImplTest, TwoClientsGetDeviceFormats) {
   EXPECT_CALL(*this, OnDeviceSupportedFormats(_)).Times(2);
+  EXPECT_CALL(mock_video_capture_host_,
+              GetDeviceSupportedFormats(_, kSessionId, _))
+      .Times(2);
 
   GetDeviceSupportedFormats();
   GetDeviceSupportedFormats();
 }
 
 // Checks that a request to GetDeviceFormatsInUse() ends up eventually in the
 // provided callback.
 TEST_F(VideoCaptureImplTest, GetDeviceFormatsInUse) {
   EXPECT_CALL(*this, OnDeviceFormatsInUse(_));
+  EXPECT_CALL(mock_video_capture_host_,
+              GetDeviceFormatsInUse(_, kSessionId, _));
 
   GetDeviceFormatsInUse();
 }
 
 TEST_F(VideoCaptureImplTest, BufferReceived) {
   base::SharedMemory shm;
   const size_t frame_size = media::VideoFrame::AllocationSize(
       media::PIXEL_FORMAT_I420, params_small_.requested_format.frame_size);
   ASSERT_TRUE(shm.CreateAndMapAnonymous(frame_size));
 
@@ skipping 64 matching lines @@
   EXPECT_CALL(mock_video_capture_host_, Start(_, kSessionId, params_small_));
 
   StartCapture(0, params_small_);
 
   video_capture_impl_->ReceiveStateChangeMessage(VIDEO_CAPTURE_STATE_ERROR);
 
   StopCapture(0);
 }
 
 }  // namespace content