Android: not to pause screen capture when Chrome is put to background

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/media_stream_options.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;
@@ skipping 196 matching lines @@
 }
 
 TEST_F(VideoCaptureImplManagerTest, NoLeak) {
   manager_->UseDevice(0).Reset();
   manager_.reset();
   cleanup_run_loop_.Run();
 }
 
 TEST_F(VideoCaptureImplManagerTest, SuspendAndResumeSessions) {
   std::array<base::Closure, kNumClients> release_callbacks;
+  StreamDeviceInfoArray video_device_array;
   for (size_t i = 0; i < kNumClients; ++i) {
     release_callbacks[i] =
         manager_->UseDevice(static_cast<media::VideoCaptureSessionId>(i));
+    StreamDeviceInfo video_device_info;
+    video_device_info.session_id = static_cast<media::VideoCaptureSessionId>(i);
+    video_device_array.push_back(video_device_info);
   }
   std::array<base::Closure, kNumClients> stop_callbacks =
       StartCaptureForAllClients(false);
 
   // Call SuspendDevices(true) to suspend all clients, and expect all to be
   // paused.
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnPaused(0)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*this, OnPaused(1)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*this, OnPaused(2)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
-    manager_->SuspendDevices(true);
+    manager_->SuspendDevices(video_device_array, true);
     run_loop.Run();
   }
 
   // Call SuspendDevices(false) and expect all to be resumed.
   {
     base::RunLoop run_loop;
     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);
+    manager_->SuspendDevices(video_device_array, false);
     run_loop.Run();
   }
 
   // Suspend just the first client and expect just the first client to be
   // paused.
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnPaused(0)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
     manager_->Suspend(0);
     run_loop.Run();
   }
 
   // Now call SuspendDevices(true) again, and expect just the second and third
   // clients to be paused.
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnPaused(1)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*this, OnPaused(2)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
-    manager_->SuspendDevices(true);
+    manager_->SuspendDevices(video_device_array, true);
     run_loop.Run();
   }
 
   // Resume just the first client, but it should not resume because all devices
   // are supposed to be suspended.
   {
     manager_->Resume(0);
     base::RunLoop().RunUntilIdle();
   }
 
   // Now, call SuspendDevices(false) and expect all to be resumed.
   {
     base::RunLoop run_loop;
     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);
+    manager_->SuspendDevices(video_device_array, false);
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
   for (const auto& release_callback : release_callbacks)
     release_callback.Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content