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

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::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::SaveArg;
 using ::testing::WithArgs;
 
 namespace content {
@@ skipping 46 matching lines @@
 
  private:
   int released_buffer_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMojoVideoCaptureHost);
 };
 
 // This class encapsulates a VideoCaptureImpl under test and the necessary
 // accessory classes, namely:
 // - a VideoCaptureMessageFilter;
-// - a MockVideoCaptureHost, mimicking the RendererHost;
+// - a MockMojoVideoCaptureHost, mimicking the RendererHost;
 // - a few callbacks that are bound when calling operations of VideoCaptureImpl
 //  and on which we set expectations.
 class VideoCaptureImplTest : public ::testing::Test {
  public:
   VideoCaptureImplTest()
       : message_filter_(new VideoCaptureMessageFilter),
         video_capture_impl_(
             new VideoCaptureImpl(kSessionId,
                                  message_filter_.get(),
                                  base::ThreadTaskRunnerHandle::Get())) {
@@ skipping 23 matching lines @@
         base::Bind(&VideoCaptureImplTest::OnFrameReady, base::Unretained(this));
 
     video_capture_impl_->StartCapture(client_id, params, state_update_callback,
                                       frame_ready_callback);
   }
 
   void StopCapture(int client_id) {
     video_capture_impl_->StopCapture(client_id);
   }
 
-  void NewBuffer(int buffer_id, const base::SharedMemory& shm) {
+  void SimulateOnBufferCreated(int buffer_id, const base::SharedMemory& shm) {
+    auto handle = base::SharedMemory::DuplicateHandle(shm.handle());
     video_capture_impl_->OnBufferCreated(
-        base::SharedMemory::DuplicateHandle(shm.handle()),
-        shm.mapped_size(), buffer_id);
+        buffer_id, mojo::WrapSharedMemoryHandle(handle, shm.mapped_size(),
+                                                true /* read_only */));
   }
 
-  void BufferReceived(int buffer_id, const gfx::Size& size) {
+  void SimulateBufferReceived(int buffer_id, const gfx::Size& size) {
     mojom::VideoFrameInfoPtr info = mojom::VideoFrameInfo::New();
 
     const base::TimeTicks now = base::TimeTicks::Now();
     media::VideoFrameMetadata frame_metadata;
     frame_metadata.SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME, now);
     frame_metadata.MergeInternalValuesInto(&info->metadata);
 
     info->timestamp = now - base::TimeTicks();
     info->pixel_format = media::PIXEL_FORMAT_I420;
     info->storage_type = media::PIXEL_STORAGE_CPU;
     info->coded_size = size;
     info->visible_rect = gfx::Rect(size);
 
     video_capture_impl_->OnBufferReady(buffer_id, std::move(info));
   }
 
-  void BufferDestroyed(int buffer_id) {
+  void SimulateBufferDestroyed(int buffer_id) {
     video_capture_impl_->OnBufferDestroyed(buffer_id);
   }
 
   void GetDeviceSupportedFormats() {
     const base::Callback<void(const media::VideoCaptureFormats&)>
         callback = base::Bind(
             &VideoCaptureImplTest::OnDeviceSupportedFormats,
             base::Unretained(this));
     video_capture_impl_->GetDeviceSupportedFormats(callback);
   }
@@ skipping 110 matching lines @@
 
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED));
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED));
   EXPECT_CALL(*this, OnFrameReady(_, _));
   EXPECT_CALL(mock_video_capture_host_, DoStart(_, kSessionId, params_small_));
   EXPECT_CALL(mock_video_capture_host_, Stop(_));
   EXPECT_CALL(mock_video_capture_host_, ReleaseBuffer(_, kBufferId, _, _))
       .Times(0);
 
   StartCapture(0, params_small_);
-  NewBuffer(kBufferId, shm);
-  BufferReceived(kBufferId, params_small_.requested_format.frame_size);
+  SimulateOnBufferCreated(kBufferId, shm);
+  SimulateBufferReceived(kBufferId, params_small_.requested_format.frame_size);
   StopCapture(0);
-  BufferDestroyed(kBufferId);
+  SimulateBufferDestroyed(kBufferId);
 
   EXPECT_EQ(mock_video_capture_host_.released_buffer_count(), 0);
 }
 
 TEST_F(VideoCaptureImplTest, BufferReceivedAfterStop) {
   const int kBufferId = 12;
 
   base::SharedMemory shm;
   const size_t frame_size = media::VideoFrame::AllocationSize(
       media::PIXEL_FORMAT_I420, params_large_.requested_format.frame_size);
   ASSERT_TRUE(shm.CreateAndMapAnonymous(frame_size));
 
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED));
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED));
   EXPECT_CALL(*this, OnFrameReady(_, _)).Times(0);
   EXPECT_CALL(mock_video_capture_host_, DoStart(_, kSessionId, params_large_));
   EXPECT_CALL(mock_video_capture_host_, Stop(_));
   EXPECT_CALL(mock_video_capture_host_, ReleaseBuffer(_, kBufferId, _, _));
 
   StartCapture(0, params_large_);
-  NewBuffer(kBufferId, shm);
+  SimulateOnBufferCreated(kBufferId, shm);
   StopCapture(0);
   // A buffer received after StopCapture() triggers an instant ReleaseBuffer().
-  BufferReceived(kBufferId, params_large_.requested_format.frame_size);
-  BufferDestroyed(kBufferId);
+  SimulateBufferReceived(kBufferId, params_large_.requested_format.frame_size);
+  SimulateBufferDestroyed(kBufferId);
 
   EXPECT_EQ(mock_video_capture_host_.released_buffer_count(), 1);
 }
 
 TEST_F(VideoCaptureImplTest, AlreadyStarted) {
   media::VideoCaptureParams params = {};
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED)).Times(2);
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED)).Times(2);
   EXPECT_CALL(mock_video_capture_host_, DoStart(_, kSessionId, _))
       .WillOnce(SaveArg<2>(&params));
@@ skipping 24 matching lines @@
   EXPECT_CALL(mock_video_capture_host_, DoStart(_, kSessionId, params_small_));
 
   StartCapture(0, params_small_);
 
   OnStateChanged(mojom::VideoCaptureState::FAILED);
 
   StopCapture(0);
 }
 
 }  // namespace content