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

content/renderer/media/video_capture_impl_manager_unittest.cc

 // Copyright 2014 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 <array>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 43 matching lines @@
                        PauseResumeCallback* pause_callback,
                        base::Closure destruct_callback)
       : VideoCaptureImpl(session_id,
                          filter,
                          ChildProcess::current()->io_task_runner()),
         pause_callback_(pause_callback),
         destruct_callback_(destruct_callback) {}
 
   ~MockVideoCaptureImpl() override { destruct_callback_.Run(); }
 
-  void Send(IPC::Message* message) override {
-    IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureImpl, *message)
-      IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Start, Start)
-      IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Resume, Resume)
-      default:
-        VideoCaptureImpl::Send(message);
-        return;
-    IPC_END_MESSAGE_MAP()
-    delete message;
-  }
-
  private:
-  MOCK_METHOD1(Stop, void(int32_t));
-  MOCK_METHOD1(RequestRefreshFrame, void(int32_t));
-
-  void Start(int device_id,
-             media::VideoCaptureSessionId session_id,
-             const media::VideoCaptureParams& params) {
+  void Start(int32_t device_id,
+             int32_t session_id,
+             const media::VideoCaptureParams& params) override {
+    // For every Start(), expect a corresponding Stop() call.
     EXPECT_CALL(*this, Stop(_));
   }
 
-  void Pause(int device_id) {
-    pause_callback_->OnPaused(session_id());
+  MOCK_METHOD1(Stop, void(int32_t));
+
+  void Pause(int device_id) { pause_callback_->OnPaused(session_id()); }
+
+  void Resume(int32_t device_id,
+              int32_t session_id,
+              const media::VideoCaptureParams& params) override {
+    pause_callback_->OnResumed(session_id);
   }
 
-  void Resume(int device_id,
-              media::VideoCaptureSessionId session_id,
-              const media::VideoCaptureParams& params) {
-    pause_callback_->OnResumed(session_id);
-  }
+  MOCK_METHOD1(RequestRefreshFrame, void(int32_t));
 
   PauseResumeCallback* const pause_callback_;
   const base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImpl);
 };
 
 class MockVideoCaptureImplManager : public VideoCaptureImplManager {
  public:
   MockVideoCaptureImplManager(PauseResumeCallback* pause_callback,
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImplManager);
 };
 
 }  // namespace
 
 class VideoCaptureImplManagerTest : public ::testing::Test,
                                     public PauseResumeCallback {
  public:
   VideoCaptureImplManagerTest()
-      : child_process_(new ChildProcess()),
-        manager_(new MockVideoCaptureImplManager(
+      : manager_(new MockVideoCaptureImplManager(
             this,
             BindToCurrentLoop(cleanup_run_loop_.QuitClosure()))) {}
 
  protected:
   static constexpr size_t kNumClients = 3;
 
   std::array<base::Closure, kNumClients> StartCaptureForAllClients(
       bool same_session_id) {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnStarted(_)).Times(kNumClients - 1)
         .RetiresOnSaturation();
     EXPECT_CALL(*this, OnStarted(_)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
     std::array<base::Closure, kNumClients> stop_callbacks;
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(176, 144), 30, media::PIXEL_FORMAT_I420);
     for (size_t i = 0; i < kNumClients; ++i) {
       stop_callbacks[i] = StartCapture(
           same_session_id ? 0 : static_cast<media::VideoCaptureSessionId>(i),
           params);
     }
-    child_process_->io_task_runner()->PostTask(
+    child_process_.io_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureMessageFilter::OnFilterAdded,
                    base::Unretained(manager_->video_capture_message_filter()),
                    nullptr));
     run_loop.Run();
     return stop_callbacks;
   }
 
   void StopCaptureForAllClients(
       std::array<base::Closure, kNumClients>* stop_callbacks) {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnStopped(_)).Times(kNumClients - 1)
         .RetiresOnSaturation();
     EXPECT_CALL(*this, OnStopped(_)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
-    for (size_t i = 0; i < kNumClients; ++i)
-      (*stop_callbacks)[i].Run();
+    for (const auto& stop_callback : *stop_callbacks)
+      stop_callback.Run();
     run_loop.Run();
   }
 
   MOCK_METHOD2(OnFrameReady,
                void(const scoped_refptr<media::VideoFrame>&,
                     base::TimeTicks estimated_capture_time));
   MOCK_METHOD1(OnStarted, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnStopped, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnPaused, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnResumed, void(media::VideoCaptureSessionId id));
@@ skipping 10 matching lines @@
   base::Closure StartCapture(media::VideoCaptureSessionId id,
                              const media::VideoCaptureParams& params) {
     return manager_->StartCapture(
         id, params, base::Bind(&VideoCaptureImplManagerTest::OnStateUpdate,
                                base::Unretained(this), id),
         base::Bind(&VideoCaptureImplManagerTest::OnFrameReady,
                    base::Unretained(this)));
   }
 
   const base::MessageLoop message_loop_;
-  const std::unique_ptr<ChildProcess> child_process_;
+  ChildProcess child_process_;
   base::RunLoop cleanup_run_loop_;
   std::unique_ptr<MockVideoCaptureImplManager> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureImplManagerTest);
 };
 
 // Multiple clients with the same session id. There is only one
 // media::VideoCapture object.
 TEST_F(VideoCaptureImplManagerTest, MultipleClients) {
   std::array<base::Closure, kNumClients> release_callbacks;
   for (size_t i = 0; i < kNumClients; ++i)
     release_callbacks[i] = manager_->UseDevice(0);
   std::array<base::Closure, kNumClients> stop_callbacks =
       StartCaptureForAllClients(true);
   StopCaptureForAllClients(&stop_callbacks);
-  for (size_t i = 0; i < kNumClients; ++i)
-    release_callbacks[i].Run();
+  for (const auto& release_callback : release_callbacks)
+    release_callback.Run();
   cleanup_run_loop_.Run();
 }
 
 TEST_F(VideoCaptureImplManagerTest, NoLeak) {
   manager_->UseDevice(0).Reset();
   manager_.reset();
   cleanup_run_loop_.Run();
 }
 
 TEST_F(VideoCaptureImplManagerTest, SuspendAndResumeSessions) {
@@ skipping 66 matching lines @@
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnResumed(0)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*this, OnResumed(1)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*this, OnResumed(2)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
     manager_->SuspendDevices(false);
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
-  for (size_t i = 0; i < kNumClients; ++i)
-    release_callbacks[i].Run();
+  for (const auto& release_callback : release_callbacks)
+    release_callback.Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content