Enable use_once_callback for //content/common/*.mojom

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/video_capture.mojom.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::SaveArg;
 using ::testing::WithArgs;
 
 namespace content {
 
 const int kSessionId = 11;
 
-void RunEmptyFormatsCallback(const VideoCaptureDeviceFormatsCB& callback) {
+void RunEmptyFormatsCallback(
+    mojom::VideoCaptureHost::GetDeviceSupportedFormatsCallback& callback) {
   media::VideoCaptureFormats formats;
-  callback.Run(formats);
+  std::move(callback).Run(formats);
 }
 
 ACTION(DoNothing) {}
 
 // Mock implementation of the Mojo Host service.
 class MockMojoVideoCaptureHost : public mojom::VideoCaptureHost {
  public:
   MockMojoVideoCaptureHost() : released_buffer_count_(0) {
-    ON_CALL(*this, GetDeviceSupportedFormats(_, _, _))
+    ON_CALL(*this, GetDeviceSupportedFormatsMock(_, _, _))
         .WillByDefault(WithArgs<2>(Invoke(RunEmptyFormatsCallback)));
-    ON_CALL(*this, GetDeviceFormatsInUse(_, _, _))
+    ON_CALL(*this, GetDeviceFormatsInUseMock(_, _, _))
         .WillByDefault(WithArgs<2>(Invoke(RunEmptyFormatsCallback)));
     ON_CALL(*this, ReleaseBuffer(_, _, _))
         .WillByDefault(InvokeWithoutArgs(
             this, &MockMojoVideoCaptureHost::increase_released_buffer_count));
   }
 
   // Start() can't be mocked directly due to move-only |observer|.
   void Start(int32_t device_id,
              int32_t session_id,
              const media::VideoCaptureParams& params,
              mojom::VideoCaptureObserverPtr observer) override {
     DoStart(device_id, session_id, params);
   }
   MOCK_METHOD3(DoStart,
                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(ReleaseBuffer, void(int32_t, int32_t, double));
-  MOCK_METHOD3(GetDeviceSupportedFormats,
-               void(int32_t,
-                    int32_t,
-                    const GetDeviceSupportedFormatsCallback&));
-  MOCK_METHOD3(GetDeviceFormatsInUse,
-               void(int32_t, int32_t, const GetDeviceFormatsInUseCallback&));
+  MOCK_METHOD3(GetDeviceSupportedFormatsMock,
+               void(int32_t, int32_t, GetDeviceSupportedFormatsCallback&));
+  MOCK_METHOD3(GetDeviceFormatsInUseMock,
+               void(int32_t, int32_t, GetDeviceFormatsInUseCallback&));
+
+  void GetDeviceSupportedFormats(
+      int32_t arg1,
+      int32_t arg2,
+      GetDeviceSupportedFormatsCallback arg3) override {
+    GetDeviceSupportedFormatsMock(arg1, arg2, arg3);
+  }
+
+  void GetDeviceFormatsInUse(int32_t arg1,
+                             int32_t arg2,
+                             GetDeviceFormatsInUseCallback arg3) override {
+    GetDeviceFormatsInUseMock(arg1, arg2, arg3);
+  }
 
   int released_buffer_count() const { return released_buffer_count_; }
   void increase_released_buffer_count() { released_buffer_count_++; }
 
  private:
   int released_buffer_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMojoVideoCaptureHost);
 };
 
@@ skipping 147 matching lines @@
   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, _));
+              GetDeviceSupportedFormatsMock(_, 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, _))
+              GetDeviceSupportedFormatsMock(_, 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, _));
+              GetDeviceFormatsInUseMock(_, kSessionId, _));
 
   GetDeviceFormatsInUse();
 }
 
 TEST_F(VideoCaptureImplTest, BufferReceived) {
   const int kBufferId = 11;
 
   base::SharedMemory shm;
   const size_t frame_size = media::VideoFrame::AllocationSize(
       media::PIXEL_FORMAT_I420, params_small_.requested_format.frame_size);
@@ skipping 108 matching lines @@
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED));
   EXPECT_CALL(mock_video_capture_host_, RequestRefreshFrame(_));
   video_capture_impl_->OnStateChanged(mojom::VideoCaptureState::STARTED);
 
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED));
   EXPECT_CALL(mock_video_capture_host_, Stop(_));
   StopCapture(0);
 }
 
 }  // namespace content