content/renderer/pepper/pepper_media_device_manager.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/pepper/pepper_media_device_manager.h"
   6
   7 #include "base/logging.h"
   8 #include "content/renderer/media/media_stream_dispatcher.h"
   9 #include "content/renderer/render_view_impl.h"
  10 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
  11
  12 namespace content {
  13
  14 namespace {
  15
  16 ppapi::DeviceRefData FromStreamDeviceInfo(const StreamDeviceInfo& info) {
  17   ppapi::DeviceRefData data;
  18   data.id = info.device.id;
  19   data.name = info.device.name;
  20   data.type = PepperMediaDeviceManager::FromMediaStreamType(info.device.type);
  21   return data;
  22 }
  23
  24 }  // namespace
  25
  26 PepperMediaDeviceManager* PepperMediaDeviceManager::GetForRenderView(
  27     RenderView* render_view) {
  28   PepperMediaDeviceManager* handler =
  29       PepperMediaDeviceManager::Get(render_view);
  30   if (!handler)
  31     handler = new PepperMediaDeviceManager(render_view);
  32   return handler;
  33 }
  34
  35 PepperMediaDeviceManager::PepperMediaDeviceManager(RenderView* render_view)
  36     : RenderViewObserver(render_view),
  37       RenderViewObserverTracker<PepperMediaDeviceManager>(render_view),
  38       next_id_(1) {}
  39
  40 PepperMediaDeviceManager::~PepperMediaDeviceManager() {
  41   DCHECK(enumerate_callbacks_.empty());
  42   DCHECK(open_callbacks_.empty());
  43 }
  44
  45 int PepperMediaDeviceManager::EnumerateDevices(
  46     PP_DeviceType_Dev type,
  47     const GURL& document_url,
  48     const EnumerateDevicesCallback& callback) {
  49   enumerate_callbacks_[next_id_] = callback;
  50   int request_id = next_id_++;
  51
  52 #if defined(ENABLE_WEBRTC)
  53   GetRenderViewImpl()->media_stream_dispatcher()->EnumerateDevices(
  54       request_id,
  55       AsWeakPtr(),
  56       PepperMediaDeviceManager::FromPepperDeviceType(type),
  57       document_url.GetOrigin());
  58 #else
  59   base::MessageLoop::current()->PostTask(
  60       FROM_HERE,
  61       base::Bind(&PepperMediaDeviceManager::OnDevicesEnumerated,
  62                  AsWeakPtr(),
  63                  request_id,
  64                  StreamDeviceInfoArray()));
  65 #endif
  66
  67   return request_id;
  68 }
  69
  70 void PepperMediaDeviceManager::StopEnumerateDevices(int request_id) {
  71   enumerate_callbacks_.erase(request_id);
  72
  73 #if defined(ENABLE_WEBRTC)
  74   // Need to post task since this function might be called inside the callback
  75   // of EnumerateDevices.
  76   base::MessageLoop::current()->PostTask(
  77       FROM_HERE,
  78       base::Bind(&MediaStreamDispatcher::StopEnumerateDevices,
  79                  GetRenderViewImpl()->media_stream_dispatcher()->AsWeakPtr(),
  80                  request_id,
  81                  AsWeakPtr()));
  82 #endif
  83 }
  84
  85 int PepperMediaDeviceManager::OpenDevice(PP_DeviceType_Dev type,
  86                                          const std::string& device_id,
  87                                          const GURL& document_url,
  88                                          const OpenDeviceCallback& callback) {
  89   open_callbacks_[next_id_] = callback;
  90   int request_id = next_id_++;
  91
  92 #if defined(ENABLE_WEBRTC)
  93   GetRenderViewImpl()->media_stream_dispatcher()->OpenDevice(
  94       request_id,
  95       AsWeakPtr(),
  96       device_id,
  97       PepperMediaDeviceManager::FromPepperDeviceType(type),
  98       document_url.GetOrigin());
  99 #else
 100   base::MessageLoop::current()->PostTask(
 101       FROM_HERE,
 102       base::Bind(&PepperMediaDeviceManager::OnDeviceOpenFailed,
 103                  AsWeakPtr(),
 104                  request_id));
 105 #endif
 106
 107   return request_id;
 108 }
 109
 110 void PepperMediaDeviceManager::CancelOpenDevice(int request_id) {
 111   open_callbacks_.erase(request_id);
 112
 113 #if defined(ENABLE_WEBRTC)
 114   GetRenderViewImpl()->media_stream_dispatcher()->CancelOpenDevice(request_id,
 115                                                                    AsWeakPtr());
 116 #endif
 117 }
 118
 119 void PepperMediaDeviceManager::CloseDevice(const std::string& label) {
 120 #if defined(ENABLE_WEBRTC)
 121   GetRenderViewImpl()->media_stream_dispatcher()->CloseDevice(label);
 122 #endif
 123 }
 124
 125 int PepperMediaDeviceManager::GetSessionID(PP_DeviceType_Dev type,
 126                                            const std::string& label) {
 127 #if defined(ENABLE_WEBRTC)
 128   switch (type) {
 129     case PP_DEVICETYPE_DEV_AUDIOCAPTURE:
 130       return GetRenderViewImpl()->media_stream_dispatcher()->audio_session_id(
 131           label, 0);
 132     case PP_DEVICETYPE_DEV_VIDEOCAPTURE:
 133       return GetRenderViewImpl()->media_stream_dispatcher()->video_session_id(
 134           label, 0);
 135     default:
 136       NOTREACHED();
 137       return 0;
 138   }
 139 #else
 140   return 0;
 141 #endif
 142 }
 143
 144 void PepperMediaDeviceManager::OnStreamGenerated(
 145     int request_id,
 146     const std::string& label,
 147     const StreamDeviceInfoArray& audio_device_array,
 148     const StreamDeviceInfoArray& video_device_array) {}
 149
 150 void PepperMediaDeviceManager::OnStreamGenerationFailed(
 151     int request_id,
 152     content::MediaStreamRequestResult result) {}
 153
 154 void PepperMediaDeviceManager::OnDeviceStopped(
 155     const std::string& label,
 156     const StreamDeviceInfo& device_info) {}
 157
 158 void PepperMediaDeviceManager::OnDevicesEnumerated(
 159     int request_id,
 160     const StreamDeviceInfoArray& device_array) {
 161   EnumerateCallbackMap::iterator iter = enumerate_callbacks_.find(request_id);
 162   if (iter == enumerate_callbacks_.end()) {
 163     // This might be enumerated result sent before StopEnumerateDevices is
 164     // called since EnumerateDevices is persistent request.
 165     return;
 166   }
 167
 168   EnumerateDevicesCallback callback = iter->second;
 169
 170   std::vector<ppapi::DeviceRefData> devices;
 171   devices.reserve(device_array.size());
 172   for (StreamDeviceInfoArray::const_iterator info = device_array.begin();
 173        info != device_array.end();
 174        ++info) {
 175     devices.push_back(FromStreamDeviceInfo(*info));
 176   }
 177   callback.Run(request_id, devices);
 178 }
 179
 180 void PepperMediaDeviceManager::OnDeviceOpened(
 181     int request_id,
 182     const std::string& label,
 183     const StreamDeviceInfo& device_info) {
 184   NotifyDeviceOpened(request_id, true, label);
 185 }
 186
 187 void PepperMediaDeviceManager::OnDeviceOpenFailed(int request_id) {
 188   NotifyDeviceOpened(request_id, false, std::string());
 189 }
 190
 191 // static
 192 MediaStreamType PepperMediaDeviceManager::FromPepperDeviceType(
 193     PP_DeviceType_Dev type) {
 194   switch (type) {
 195     case PP_DEVICETYPE_DEV_INVALID:
 196       return MEDIA_NO_SERVICE;
 197     case PP_DEVICETYPE_DEV_AUDIOCAPTURE:
 198       return MEDIA_DEVICE_AUDIO_CAPTURE;
 199     case PP_DEVICETYPE_DEV_VIDEOCAPTURE:
 200       return MEDIA_DEVICE_VIDEO_CAPTURE;
 201     default:
 202       NOTREACHED();
 203       return MEDIA_NO_SERVICE;
 204   }
 205 }
 206
 207 // static
 208 PP_DeviceType_Dev PepperMediaDeviceManager::FromMediaStreamType(
 209     MediaStreamType type) {
 210   switch (type) {
 211     case MEDIA_NO_SERVICE:
 212       return PP_DEVICETYPE_DEV_INVALID;
 213     case MEDIA_DEVICE_AUDIO_CAPTURE:
 214       return PP_DEVICETYPE_DEV_AUDIOCAPTURE;
 215     case MEDIA_DEVICE_VIDEO_CAPTURE:
 216       return PP_DEVICETYPE_DEV_VIDEOCAPTURE;
 217     default:
 218       NOTREACHED();
 219       return PP_DEVICETYPE_DEV_INVALID;
 220   }
 221 }
 222
 223 void PepperMediaDeviceManager::NotifyDeviceOpened(int request_id,
 224                                                   bool succeeded,
 225                                                   const std::string& label) {
 226   OpenCallbackMap::iterator iter = open_callbacks_.find(request_id);
 227   if (iter == open_callbacks_.end()) {
 228     // The callback may have been unregistered.
 229     return;
 230   }
 231
 232   OpenDeviceCallback callback = iter->second;
 233   open_callbacks_.erase(iter);
 234
 235   callback.Run(request_id, succeeded, label);
 236 }
 237
 238 RenderViewImpl* PepperMediaDeviceManager::GetRenderViewImpl() {
 239   return static_cast<RenderViewImpl*>(render_view());
 240 }
 241
 242 }  // namespace content