Home | History | Annotate | Download | only in media 
      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 
     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 
     28 MockMediaStreamDispatcher::~MockMediaStreamDispatcher() {}
     29 
     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 
     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 
     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 
     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 
     93 bool MockMediaStreamDispatcher::IsStream(const std::string& label) {
     94   return true;
     95 }
     96 
     97 int MockMediaStreamDispatcher::video_session_id(const std::string& label,
     98                                                 int index) {
     99   return -1;
    100 }
    101 
    102 int MockMediaStreamDispatcher::audio_session_id(const std::string& label,
    103                                                 int index) {
    104   return -1;
    105 }
    106 
    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 
    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 
    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