Reland: VideoCapture: migrate VideoCapture renderer-->host messages to mojo, part 1

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 49 matching lines @@
 // Id used to identify the capture session between renderer and
 // video_capture_host. This is an arbitrary value.
 static const int kDeviceId = 555;
 
 // Define to enable test where video is dumped to file.
 // #define DUMP_VIDEO
 
 // Define to use a real video capture device.
 // #define TEST_REAL_CAPTURE_DEVICE
 
-// Simple class used for dumping video to a file. This can be used for
-// verifying the output.
+// Simple class used for dumping video to a file. This can be used for verifying
+// the output.
 class DumpVideo {
  public:
   DumpVideo() {}
   const gfx::Size& coded_size() const { return coded_size_; }
   void StartDump(const gfx::Size& coded_size) {
     base::FilePath file_name = base::FilePath(base::StringPrintf(
         FILE_PATH_LITERAL("dump_w%d_h%d.yuv"),
         coded_size.width(),
         coded_size.height()));
     file_.reset(base::OpenFile(file_name, "wb"));
@@ skipping 38 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 {

[mcasas, 2016/10/05 23:42:02]

After the renaming in this PS, the linker
started silently linking this MockVideoCaptureHost
instead of the one in video_capture_impl_unittests,
causing strange crashes on destruction in that
test.  I sorted it out and cleaned up the tests in
the process (indenting etc).

  public:
   MockVideoCaptureHost(MediaStreamManager* manager)
       : VideoCaptureHost(manager),
         return_buffers_(false),
         dump_video_(false) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnNewBufferCreated,
                void(int device_id,
                     base::SharedMemoryHandle handle,
@@ skipping 143 matching lines @@
     host_ = new MockVideoCaptureHost(media_stream_manager_.get());
     host_->OnChannelConnected(base::GetCurrentProcId());
 
     OpenSession();
   }
 
   void TearDown() override {
     // Verifies and removes the expectations on host_ and
     // returns true iff successful.
     Mock::VerifyAndClearExpectations(host_.get());
-    EXPECT_EQ(0u, host_->entries_.size());
+    EXPECT_TRUE(host_->controllers_.empty());
 
     CloseSession();
 
     // Simulate closing the IPC sender.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object. The object will be destructed
     // on the current message loop.
     host_ = NULL;
 
@@ skipping 90 matching lines @@
     // 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_->OnStartCapture(kDeviceId, opened_session_id_, params);
-    host_->OnStopCapture(kDeviceId);
+    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));
+    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);
+    host_->OnResumeCapture(kDeviceId, opened_session_id_, params);
+    run_loop.RunUntilIdle();
+    WaitForVideoDeviceThread();
+  }
 
 #ifdef DUMP_VIDEO
   void CaptureAndDumpVideo(int width, int height, int frame_rate) {
     InSequence s;
     EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber()).WillRepeatedly(Return());
 
     base::RunLoop run_loop;
     EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _, _, _, _, _, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     media::VideoCaptureParams params;
     params.requested_format =
         media::VideoCaptureFormat(gfx::Size(width, height), frame_rate);
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 #endif
 
   void StopCapture() {
     base::RunLoop run_loop;
     EXPECT_CALL(*host_.get(),
                 OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
         .WillOnce(ExitMessageLoop(task_runner_, run_loop.QuitClosure()));
 
-    host_->OnStopCapture(kDeviceId);
+    host_->Stop(kDeviceId);
     host_->SetReturnReceivedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     run_loop.Run();
 
     host_->SetReturnReceivedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
-    EXPECT_EQ(0u, host_->entries_.size());
+    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();
   }
@@ skipping 18 matching lines @@
         ->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. audio_manager_ needs to outlive
-  // thread_bundle_ because it uses the underlying message loop.
+  // |media_stream_manager_| needs to outlive |thread_bundle_| because it is a
+  // MessageLoop::DestructionObserver. |audio_manager_| needs to outlive
+  // |thread_bundle_| because it uses the underlying message loop.
   StrictMock<MockMediaStreamRequester> stream_requester_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
-  content::TestBrowserThreadBundle thread_bundle_;
+  const content::TestBrowserThreadBundle thread_bundle_;
   media::ScopedAudioManagerPtr audio_manager_;
   content::TestBrowserContext browser_context_;
   content::TestContentBrowserClient browser_client_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   int opened_session_id_;
   std::string opened_device_label_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
 TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
   StartCapture();
 
   // When the session is closed via the stream without stopping capture, the
@@ skipping 33 matching lines @@
 
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
+TEST_F(VideoCaptureHostTest, PauseResumeCapture) {
+  StartCapture();
+  PauseResumeCapture();
+  StopCapture();
+}
+
 }  // namespace content