getUserMedia: handle the device starting status report.

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/video_capture.mojom.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "content/renderer/media/video_capture_impl_manager.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::InSequence;
 using ::testing::SaveArg;
 using media::BindToCurrentLoop;
 
 namespace content {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 namespace {
@@ skipping 22 matching lines @@
 
   ~MockVideoCaptureImpl() override { destruct_callback_.Run(); }
 
  private:
   void Start(int32_t device_id,
              int32_t session_id,
              const media::VideoCaptureParams& params,
              mojom::VideoCaptureObserverPtr observer) override {
     // For every Start(), expect a corresponding Stop() call.
     EXPECT_CALL(*this, Stop(_));
+    // Simulate device started.
+    OnStateChanged(mojom::VideoCaptureState::STARTED);
   }
 
   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);
@@ skipping 48 matching lines @@
             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();
+
+    InSequence s;
+    if (!same_session_id) {
+      // |OnStarted| will only be received once from each device if there are
+      // multiple request to the same device.
+      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);
@@ skipping 146 matching lines @@
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
   for (const auto& release_callback : release_callbacks)
     release_callback.Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content