content/renderer/media/mock_media_stream_dispatcher.cc

   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