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

content/renderer/media/media_stream_dispatcher_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/renderer/media/media_stream_dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "media/base/audio_parameters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 const int kRouteId = 0;
 const int kAudioSessionId = 3;
 const int kVideoSessionId = 5;
+const int kScreenSessionId = 7;
 const int kRequestId1 = 10;
 const int kRequestId2 = 20;
 
 const MediaStreamType kAudioType = MEDIA_DEVICE_AUDIO_CAPTURE;
 const MediaStreamType kVideoType = MEDIA_DEVICE_VIDEO_CAPTURE;
+const MediaStreamType kScreenType = MEDIA_DESKTOP_VIDEO_CAPTURE;
 
 class MockMediaStreamDispatcherEventHandler
     : public MediaStreamDispatcherEventHandler,
       public base::SupportsWeakPtr<MockMediaStreamDispatcherEventHandler> {
  public:
   MockMediaStreamDispatcherEventHandler() : request_id_(-1) {}
 
   void OnStreamGenerated(
       int request_id,
       const std::string& label,
@@ skipping 327 matching lines @@
 
   dispatcher_->OnMessageReceived(
       MediaStreamMsg_DeviceStopped(kRouteId, label, handler_->video_device_));
   // Verify that MediaStreamDispatcherEventHandler::OnDeviceStopped has been
   // called.
   EXPECT_EQ(label, handler_->device_stopped_label_);
   EXPECT_EQ(dispatcher_->video_session_id(label, 0),
             StreamDeviceInfo::kNoId);
 }
 
+TEST_F(MediaStreamDispatcherTest, GetVideoCaptureDevices) {
+  std::unique_ptr<MediaStreamDispatcher> dispatcher(
+      new MediaStreamDispatcher(NULL));

[tommi (sloooow) - chröme, 2017/03/21 09:21:17]

nullptr

[braveyao, 2017/03/22 00:45:32]

Done.

+  std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler(
+      new MockMediaStreamDispatcherEventHandler);
+  url::Origin security_origin;
+
+  StreamDeviceInfo video_device_info;
+  video_device_info.device.name = "Camera";
+  video_device_info.device.id = "device_path";
+  video_device_info.device.type = kVideoType;
+  video_device_info.session_id = kVideoSessionId;
+
+  StreamDeviceInfo screen_device_info;
+  screen_device_info.device.name = "Screen";
+  screen_device_info.device.id = "screen_capture";
+  screen_device_info.device.type = kScreenType;
+  screen_device_info.session_id = kScreenSessionId;
+
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));

[tommi (sloooow) - chröme, 2017/03/21 09:21:17]

EXPECT_TRUE(dispatcher->requests_.empty());

In Chromium we also don't use C style casts such as (type)i or type(i). Instead
we use one of static_cast<>, reinterpret_cast<> or other custom casting
templates available in base/

However, for casting a constant to size_t, you don't need a cast.  If an
unsigned value is all you want, just append 'u'.  E.g. 2u.

[braveyao, 2017/03/22 00:45:32]

Acknowledged.
Done.

+  EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
+
+  int ipc_request_id1 = dispatcher->next_ipc_id_;
+  dispatcher->OpenDevice(kRequestId1, handler.get()->AsWeakPtr(),
+                         video_device_info.device.id, kVideoType,
+                         security_origin);
+  int ipc_request_id2 = dispatcher->next_ipc_id_;
+  EXPECT_NE(ipc_request_id1, ipc_request_id2);
+  dispatcher->OpenDevice(kRequestId2, handler.get()->AsWeakPtr(),
+                         screen_device_info.device.id, kScreenType,
+                         security_origin);
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
+
+  // Complete the OpenDevice of request 1.
+  std::string stream_label1 = std::string("stream1");
+  dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
+      kRouteId, ipc_request_id1, stream_label1, video_device_info));
+  EXPECT_EQ(handler->request_id_, kRequestId1);
+
+  // Complete the OpenDevice of request 2.
+  std::string stream_label2 = std::string("stream2");
+  dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
+      kRouteId, ipc_request_id2, stream_label2, screen_device_info));
+  EXPECT_EQ(handler->request_id_, kRequestId2);
+
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
+  EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(2));
+
+  // Only the device with |kVideoType| will be got.
+  StreamDeviceInfoArray video_device_array;
+  dispatcher->GetVideoCaptureDevices(video_device_array);
+  EXPECT_EQ(video_device_array.size(), size_t(1));
+
+  // Close the device from request 2.
+  dispatcher->CloseDevice(stream_label2);
+  EXPECT_EQ(dispatcher->video_session_id(stream_label2, 0),
+            StreamDeviceInfo::kNoId);
+
+  // Close the device from request 1.
+  dispatcher->CloseDevice(stream_label1);
+  EXPECT_EQ(dispatcher->video_session_id(stream_label1, 0),
+            StreamDeviceInfo::kNoId);
+
+  // Verify that the request have been completed.
+  EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
+}
+
 }  // namespace content