1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/renderer/media/mock_media_stream_dispatcher.h"
6
7 #include "base/strings/string_number_conversions.h"
8 #include "content/public/common/media_stream_request.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10
11 // Used for ID for output devices and for matching output device ID for input
12 // devices.
13 const char kAudioOutputDeviceIdPrefix[] = "audio_output_device_id";
14
15 namespace content {
16
MockMediaStreamDispatcher()17 MockMediaStreamDispatcher::MockMediaStreamDispatcher()
18 : MediaStreamDispatcher(NULL),
19 audio_input_request_id_(-1),
20 audio_output_request_id_(-1),
21 video_request_id_(-1),
22 request_stream_counter_(0),
23 stop_audio_device_counter_(0),
24 stop_video_device_counter_(0),
25 session_id_(0) {
26 }
27
~MockMediaStreamDispatcher()28 MockMediaStreamDispatcher::~MockMediaStreamDispatcher() {}
29
GenerateStream(int request_id,const base::WeakPtr<MediaStreamDispatcherEventHandler> & event_handler,const StreamOptions & components,const GURL & url)30 void MockMediaStreamDispatcher::GenerateStream(
31 int request_id,
32 const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
33 const StreamOptions& components,
34 const GURL& url) {
35 // Audio and video share the same request so we use |audio_input_request_id_|
36 // only.
37 audio_input_request_id_ = request_id;
38
39 stream_label_ = "local_stream" + base::IntToString(request_id);
40 audio_input_array_.clear();
41 video_array_.clear();
42
43 if (components.audio_requested) {
44 AddAudioInputDeviceToArray(false);
45 }
46 if (components.video_requested) {
47 AddVideoDeviceToArray(true);
48 }
49 ++request_stream_counter_;
50 }
51
CancelGenerateStream(int request_id,const base::WeakPtr<MediaStreamDispatcherEventHandler> & event_handler)52 void MockMediaStreamDispatcher::CancelGenerateStream(
53 int request_id,
54 const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
55 EXPECT_EQ(request_id, audio_input_request_id_);
56 }
57
EnumerateDevices(int request_id,const base::WeakPtr<MediaStreamDispatcherEventHandler> & event_handler,MediaStreamType type,const GURL & security_origin)58 void MockMediaStreamDispatcher::EnumerateDevices(
59 int request_id,
60 const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
61 MediaStreamType type,
62 const GURL& security_origin) {
63 if (type == MEDIA_DEVICE_AUDIO_CAPTURE) {
64 audio_input_request_id_ = request_id;
65 audio_input_array_.clear();
66 AddAudioInputDeviceToArray(true);
67 AddAudioInputDeviceToArray(false);
68 } else if (type == MEDIA_DEVICE_AUDIO_OUTPUT) {
69 audio_output_request_id_ = request_id;
70 audio_output_array_.clear();
71 AddAudioOutputDeviceToArray();
72 } else if (type == MEDIA_DEVICE_VIDEO_CAPTURE) {
73 video_request_id_ = request_id;
74 video_array_.clear();
75 AddVideoDeviceToArray(true);
76 AddVideoDeviceToArray(false);
77 }
78 }
79
StopStreamDevice(const StreamDeviceInfo & device_info)80 void MockMediaStreamDispatcher::StopStreamDevice(
81 const StreamDeviceInfo& device_info) {
82 if (IsAudioInputMediaType(device_info.device.type)) {
83 ++stop_audio_device_counter_;
84 return;
85 }
86 if (IsVideoMediaType(device_info.device.type)) {
87 ++stop_video_device_counter_;
88 return;
89 }
90 NOTREACHED();
91 }
92
IsStream(const std::string & label)93 bool MockMediaStreamDispatcher::IsStream(const std::string& label) {
94 return true;
95 }
96
video_session_id(const std::string & label,int index)97 int MockMediaStreamDispatcher::video_session_id(const std::string& label,
98 int index) {
99 return -1;
100 }
101
audio_session_id(const std::string & label,int index)102 int MockMediaStreamDispatcher::audio_session_id(const std::string& label,
103 int index) {
104 return -1;
105 }
106
AddAudioInputDeviceToArray(bool matched_output)107 void MockMediaStreamDispatcher::AddAudioInputDeviceToArray(
108 bool matched_output) {
109 StreamDeviceInfo audio;
110 audio.device.id = "audio_input_device_id" + base::IntToString(session_id_);
111 audio.device.name = "microphone";
112 audio.device.type = MEDIA_DEVICE_AUDIO_CAPTURE;
113 audio.device.video_facing = MEDIA_VIDEO_FACING_NONE;
114 if (matched_output) {
115 audio.device.matched_output_device_id =
116 kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
117 }
118 audio.session_id = session_id_;
119 audio_input_array_.push_back(audio);
120 }
121
AddAudioOutputDeviceToArray()122 void MockMediaStreamDispatcher::AddAudioOutputDeviceToArray() {
123 StreamDeviceInfo audio;
124 audio.device.id = kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
125 audio.device.name = "speaker";
126 audio.device.type = MEDIA_DEVICE_AUDIO_OUTPUT;
127 audio.device.video_facing = MEDIA_VIDEO_FACING_NONE;
128 audio.session_id = session_id_;
129 audio_output_array_.push_back(audio);
130 }
131
AddVideoDeviceToArray(bool facing_user)132 void MockMediaStreamDispatcher::AddVideoDeviceToArray(bool facing_user) {
133 StreamDeviceInfo video;
134 video.device.id = "video_device_id" + base::IntToString(session_id_);
135 video.device.name = "usb video camera";
136 video.device.type = MEDIA_DEVICE_VIDEO_CAPTURE;
137 video.device.video_facing = facing_user ? MEDIA_VIDEO_FACING_USER
138 : MEDIA_VIDEO_FACING_ENVIRONMENT;
139 video.session_id = session_id_;
140 video_array_.push_back(video);
141 }
142
143 } // namespace content
144