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();
  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();
  76   }
  77 }
  78
  79 void MockMediaStreamDispatcher::StopStreamDevice(
  80     const StreamDeviceInfo& device_info) {
  81   if (IsAudioInputMediaType(device_info.device.type)) {
  82     ++stop_audio_device_counter_;
  83     return;
  84   }
  85   if (IsVideoMediaType(device_info.device.type)) {
  86     ++stop_video_device_counter_;
  87     return;
  88   }
  89   NOTREACHED();
  90 }
  91
  92 bool MockMediaStreamDispatcher::IsStream(const std::string& label) {
  93   return true;
  94 }
  95
  96 int MockMediaStreamDispatcher::video_session_id(const std::string& label,
  97                                                 int index) {
  98   return -1;
  99 }
 100
 101 int MockMediaStreamDispatcher::audio_session_id(const std::string& label,
 102                                                 int index) {
 103   return -1;
 104 }
 105
 106 void MockMediaStreamDispatcher::AddAudioInputDeviceToArray(
 107     bool matched_output) {
 108   StreamDeviceInfo audio;
 109   audio.device.id = "audio_input_device_id" + base::IntToString(session_id_);
 110   audio.device.name = "microphone";
 111   audio.device.type = MEDIA_DEVICE_AUDIO_CAPTURE;
 112   if (matched_output) {
 113     audio.device.matched_output_device_id =
 114         kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
 115   }
 116   audio.session_id = session_id_;
 117   audio_input_array_.push_back(audio);
 118 }
 119
 120 void MockMediaStreamDispatcher::AddAudioOutputDeviceToArray() {
 121   StreamDeviceInfo audio;
 122   audio.device.id = kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
 123   audio.device.name = "speaker";
 124   audio.device.type = MEDIA_DEVICE_AUDIO_OUTPUT;
 125   audio.session_id = session_id_;
 126   audio_output_array_.push_back(audio);
 127 }
 128
 129 void MockMediaStreamDispatcher::AddVideoDeviceToArray() {
 130   StreamDeviceInfo video;
 131   video.device.id = "video_device_id" + base::IntToString(session_id_);
 132   video.device.name = "usb video camera";
 133   video.device.type = MEDIA_DEVICE_VIDEO_CAPTURE;
 134   video.session_id = session_id_;
 135   video_array_.push_back(video);
 136 }
 137
 138 }  // namespace content