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.
13const char kAudioOutputDeviceIdPrefix[] = "audio_output_device_id";
14
15namespace content {
16
17MockMediaStreamDispatcher::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
28MockMediaStreamDispatcher::~MockMediaStreamDispatcher() {}
29
30void 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
52void MockMediaStreamDispatcher::CancelGenerateStream(
53    int request_id,
54    const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
55  EXPECT_EQ(request_id, audio_input_request_id_);
56}
57
58void 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
80void 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
93bool MockMediaStreamDispatcher::IsStream(const std::string& label) {
94  return true;
95}
96
97int MockMediaStreamDispatcher::video_session_id(const std::string& label,
98                                                int index) {
99  return -1;
100}
101
102int MockMediaStreamDispatcher::audio_session_id(const std::string& label,
103                                                int index) {
104  return -1;
105}
106
107void 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
122void 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
132void 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