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

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"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_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 "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/video_capture_message_filter.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::DoAll;
 using ::testing::SaveArg;
 using media::BindToCurrentLoop;
 
 namespace content {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 namespace {
 
-// Callback interface to be implemented by
-// VideoCaptureImplManagerTest. MockVideoCaptureImpl intercepts IPC messages and
-// calls these methods to simulate what the VideoCaptureHost would do.
+// Callback interface to be implemented by VideoCaptureImplManagerTest.
+// MockVideoCaptureImpl intercepts IPC messages and calls these methods to
+// simulate what the VideoCaptureHost would do.
 class PauseResumeCallback {
  public:
   PauseResumeCallback() {}
   virtual ~PauseResumeCallback() {}
 
   virtual void OnPaused(media::VideoCaptureSessionId session_id) = 0;
   virtual void OnResumed(media::VideoCaptureSessionId session_id) = 0;
 };
 
-class MockVideoCaptureImpl : public VideoCaptureImpl {
+class MockVideoCaptureImpl : public VideoCaptureImpl,
+                             public mojom::VideoCaptureHost {
  public:
   MockVideoCaptureImpl(media::VideoCaptureSessionId session_id,
                        VideoCaptureMessageFilter* filter,
                        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_Pause, DevicePauseCapture)
-      IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Resume, DeviceResumeCapture)
+      IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Start, Start)
+      IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Resume, Resume)
       default:
         VideoCaptureImpl::Send(message);
         return;
     IPC_END_MESSAGE_MAP()
     delete message;
   }
 
  private:
-  void DevicePauseCapture(int device_id) {
+  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) {
+    EXPECT_CALL(*this, Stop(_));
+  }
+
+  void Pause(int device_id) {
     pause_callback_->OnPaused(session_id());
   }
 
-  void DeviceResumeCapture(int device_id,
-                           media::VideoCaptureSessionId session_id,
-                           const media::VideoCaptureParams& params) {
+  void Resume(int device_id,
+              media::VideoCaptureSessionId session_id,
+              const media::VideoCaptureParams& params) {
     pause_callback_->OnResumed(session_id);
   }
 
   PauseResumeCallback* const pause_callback_;
   const base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImpl);
 };
 
 class MockVideoCaptureImplManager : public VideoCaptureImplManager {
  public:
   MockVideoCaptureImplManager(PauseResumeCallback* pause_callback,
                               base::Closure destruct_video_capture_callback)
       : pause_callback_(pause_callback),
         destruct_video_capture_callback_(destruct_video_capture_callback) {}
   ~MockVideoCaptureImplManager() override {}
 
- protected:
+ private:
   std::unique_ptr<VideoCaptureImpl> CreateVideoCaptureImplForTesting(
       media::VideoCaptureSessionId id,
       VideoCaptureMessageFilter* filter) const override {
-    return base::MakeUnique<MockVideoCaptureImpl>(
+    auto video_capture_impl = base::MakeUnique<MockVideoCaptureImpl>(
         id, filter, pause_callback_, destruct_video_capture_callback_);
+    video_capture_impl->SetVideoCaptureHostForTesting(
+        video_capture_impl.get());
+    return std::move(video_capture_impl);
   }
 
- private:
   PauseResumeCallback* const pause_callback_;
   const base::Closure destruct_video_capture_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImplManager);
 };
 
 }  // namespace
 
 class VideoCaptureImplManagerTest : public ::testing::Test,
                                     public PauseResumeCallback {
@@ skipping 177 matching lines @@
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
   for (size_t i = 0; i < kNumClients; ++i)
     release_callbacks[i].Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content