Implement device enumeration for PPB_VideoCapture_Dev.

content/renderer/pepper_plugin_delegate_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
+#include <map>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/string_split.h"
 #include "base/sync_socket.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/child_thread.h"
 #include "content/common/file_system/file_system_dispatcher.h"
 #include "content/common/file_system_messages.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/pepper_file_messages.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/pepper_messages.h"
 #include "content/common/quota_dispatcher.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/gamepad_shared_memory_reader.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/gpu/renderer_gl_context.h"
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
+#include "content/renderer/media/media_stream_dispatcher.h"
+#include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/p2p/p2p_transport_impl.h"
 #include "content/renderer/pepper_platform_context_3d_impl.h"
 #include "content/renderer/pepper_platform_video_decoder_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/webplugin_delegate_proxy.h"
 #include "ipc/ipc_channel_handle.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/video/capture/video_capture_proxy.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/ppb_device_ref_shared.h"
 #include "ppapi/shared_impl/platform_file.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
@@ skipping 512 matching lines @@
     NOTREACHED();
   }
   virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE {
     callback_.Run(0);
   }
  private:
   PluginCallback callback_;
 };
 
 class PlatformVideoCaptureImpl
-    : public webkit::ppapi::PluginDelegate::PlatformVideoCapture {
+    : public webkit::ppapi::PluginDelegate::PlatformVideoCapture,
+      public media::VideoCapture::EventHandler {
  public:
-  PlatformVideoCaptureImpl(media::VideoCapture::EventHandler* handler)
-      : handler_proxy_(new media::VideoCaptureHandlerProxy(
-            handler, base::MessageLoopProxy::current())) {
+  PlatformVideoCaptureImpl(
+      const base::WeakPtr<PepperPluginDelegateImpl>& plugin_delegate,
+      const std::string& device_id,
+      webkit::ppapi::PluginDelegate::PlatformVideoCaptureEventHandler* handler);
+  virtual ~PlatformVideoCaptureImpl();
+
+  // webkit::ppapi::PluginDelegate::PlatformVideoCapture implementation.
+  virtual void StartCapture(EventHandler* handler,
+                            const VideoCaptureCapability& capability) OVERRIDE;
+  virtual void StopCapture(EventHandler* handler) OVERRIDE;
+  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE;
+  virtual bool CaptureStarted() OVERRIDE;
+  virtual int CaptureWidth() OVERRIDE;
+  virtual int CaptureHeight() OVERRIDE;
+  virtual int CaptureFrameRate() OVERRIDE;
+  virtual void DetachEventHandler() OVERRIDE;
+
+  // media::VideoCapture::EventHandler implementation
+  virtual void OnStarted(VideoCapture* capture) OVERRIDE;
+  virtual void OnStopped(VideoCapture* capture) OVERRIDE;
+  virtual void OnPaused(VideoCapture* capture) OVERRIDE;
+  virtual void OnError(VideoCapture* capture, int error_code) OVERRIDE;
+  virtual void OnRemoved(VideoCapture* capture) OVERRIDE;
+  virtual void OnBufferReady(VideoCapture* capture,
+                             scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE;
+  virtual void OnDeviceInfoReceived(
+      VideoCapture* capture,
+      const media::VideoCaptureParams& device_info) OVERRIDE;
+
+ private:
+  void Initialize();
+
+  void OnDeviceOpened(int request_id,
+                      bool succeeded,
+                      const std::string& label);
+
+  base::WeakPtr<PepperPluginDelegateImpl> plugin_delegate_;
+
+  std::string device_id_;
+  std::string label_;
+  int session_id_;
+
+  scoped_ptr<media::VideoCaptureHandlerProxy> handler_proxy_;
+
+  webkit::ppapi::PluginDelegate::PlatformVideoCaptureEventHandler* handler_;
+
+  media::VideoCapture* video_capture_;
+
+  // StartCapture() must be balanced by StopCapture(), otherwise this object
+  // will leak.
+  bool unbalanced_start_;
+
+  base::WeakPtrFactory<PlatformVideoCaptureImpl> weak_ptr_factory_;
+};
+
+PlatformVideoCaptureImpl::PlatformVideoCaptureImpl(
+    const base::WeakPtr<PepperPluginDelegateImpl>& plugin_delegate,
+    const std::string& device_id,
+    webkit::ppapi::PluginDelegate::PlatformVideoCaptureEventHandler* handler)
+    : plugin_delegate_(plugin_delegate),
+      device_id_(device_id),
+      session_id_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          handler_proxy_(new media::VideoCaptureHandlerProxy(
+              this, base::MessageLoopProxy::current()))),
+      handler_(handler),
+      video_capture_(NULL),
+      unbalanced_start_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+  if (device_id.empty()) {
+    // "1" is the session ID for the default device.
+    session_id_ = 1;
+    Initialize();
+  } else {
+    // We need to open the device and obtain the label and session ID before
+    // initializing.
+    if (plugin_delegate_) {
+      plugin_delegate_->OpenDevice(
+          PP_DEVICETYPE_DEV_VIDEOCAPTURE, device_id,
+          base::Bind(&PlatformVideoCaptureImpl::OnDeviceOpened,
+                     weak_ptr_factory_.GetWeakPtr()));
+    }
+  }
+}
+
+PlatformVideoCaptureImpl::~PlatformVideoCaptureImpl() {
+  if (video_capture_) {
     VideoCaptureImplManager* manager =
         RenderThreadImpl::current()->video_capture_impl_manager();
-    // 1 means the "default" video capture device.
-    // TODO(piman): Add a way to enumerate devices and pass them through the
-    // API.
-    video_capture_ = manager->AddDevice(1, handler_proxy_.get());
-  }
-
-  // Overrides from media::VideoCapture::EventHandler
-  virtual ~PlatformVideoCaptureImpl() {
-    VideoCaptureImplManager* manager =
-        RenderThreadImpl::current()->video_capture_impl_manager();
-    manager->RemoveDevice(1, handler_proxy_.get());
-  }
-
-  virtual void StartCapture(
-      EventHandler* handler,
-      const VideoCaptureCapability& capability) OVERRIDE {
-    DCHECK(handler == handler_proxy_->proxied());
+    manager->RemoveDevice(session_id_, handler_proxy_.get());
+  }
+
+  if (plugin_delegate_ && !label_.empty())
+    plugin_delegate_->CloseDevice(label_);
+}
+
+void PlatformVideoCaptureImpl::StartCapture(
+    EventHandler* handler,
+    const VideoCaptureCapability& capability) {
+  DCHECK(handler == handler_);
+
+  if (unbalanced_start_)
+    return;
+
+  if (video_capture_) {
+    unbalanced_start_ = true;
+    AddRef();  // Will be balanced in OnRemoved().
     video_capture_->StartCapture(handler_proxy_.get(), capability);
   }
-
-  virtual void StopCapture(EventHandler* handler) OVERRIDE {
-    DCHECK(handler == handler_proxy_->proxied());
+}
+
+void PlatformVideoCaptureImpl::StopCapture(EventHandler* handler) {
+  DCHECK(handler == handler_);
+  if (!unbalanced_start_)
+    return;
+
+  if (video_capture_) {
+    unbalanced_start_ = false;
     video_capture_->StopCapture(handler_proxy_.get());
   }
-
-  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE {
+}
+
+void PlatformVideoCaptureImpl::FeedBuffer(
+    scoped_refptr<VideoFrameBuffer> buffer) {
+  if (video_capture_)
     video_capture_->FeedBuffer(buffer);
-  }
-
-  virtual bool CaptureStarted() OVERRIDE {
-    return handler_proxy_->state().started;
-  }
-
-  virtual int CaptureWidth() OVERRIDE {
-    return handler_proxy_->state().width;
-  }
-
-  virtual int CaptureHeight() OVERRIDE {
-    return handler_proxy_->state().height;
-  }
-
-  virtual int CaptureFrameRate() OVERRIDE {
-    return handler_proxy_->state().frame_rate;
-  }
-
- private:
-  scoped_ptr<media::VideoCaptureHandlerProxy> handler_proxy_;
-  media::VideoCapture* video_capture_;
-};
+}
+
+bool PlatformVideoCaptureImpl::CaptureStarted() {
+  return handler_proxy_->state().started;
+}
+
+int PlatformVideoCaptureImpl::CaptureWidth() {
+  return handler_proxy_->state().width;
+}
+
+int PlatformVideoCaptureImpl::CaptureHeight() {
+  return handler_proxy_->state().height;
+}
+
+int PlatformVideoCaptureImpl::CaptureFrameRate() {
+  return handler_proxy_->state().frame_rate;
+}
+
+void PlatformVideoCaptureImpl::DetachEventHandler() {
+  handler_ = NULL;
+  StopCapture(NULL);
+}
+
+void PlatformVideoCaptureImpl::OnStarted(VideoCapture* capture) {
+  if (handler_)
+    handler_->OnStarted(capture);
+}
+
+void PlatformVideoCaptureImpl::OnStopped(VideoCapture* capture) {
+  if (handler_)
+    handler_->OnStopped(capture);
+}
+
+void PlatformVideoCaptureImpl::OnPaused(VideoCapture* capture) {
+  if (handler_)
+    handler_->OnPaused(capture);
+}
+
+void PlatformVideoCaptureImpl::OnError(VideoCapture* capture, int error_code) {
+  if (handler_)
+    handler_->OnError(capture, error_code);
+}
+
+void PlatformVideoCaptureImpl::OnRemoved(VideoCapture* capture) {
+  if (handler_)
+    handler_->OnRemoved(capture);
+
+  Release();  // Balance the AddRef() in StartCapture().
+}
+
+void PlatformVideoCaptureImpl::OnBufferReady(
+    VideoCapture* capture,
+    scoped_refptr<VideoFrameBuffer> buffer) {
+  if (handler_) {
+    handler_->OnBufferReady(capture, buffer);
+  } else {
+    // Even after handler_ is detached, we have to return buffers that are in
+    // flight to us. Otherwise VideoCaptureController will not tear down.
+    FeedBuffer(buffer);
+  }
+}
+
+void PlatformVideoCaptureImpl::OnDeviceInfoReceived(
+    VideoCapture* capture,
+    const media::VideoCaptureParams& device_info) {
+  if (handler_)
+    handler_->OnDeviceInfoReceived(capture, device_info);
+}
+
+void PlatformVideoCaptureImpl::Initialize() {
+  VideoCaptureImplManager* manager =
+      RenderThreadImpl::current()->video_capture_impl_manager();
+  video_capture_ = manager->AddDevice(session_id_, handler_proxy_.get());
+}
+
+void PlatformVideoCaptureImpl::OnDeviceOpened(int request_id,
+                                              bool succeeded,
+                                              const std::string& label) {
+  succeeded = succeeded && plugin_delegate_;
+  if (succeeded) {
+    label_ = label;
+    session_id_ = plugin_delegate_->GetSessionID(PP_DEVICETYPE_DEV_VIDEOCAPTURE,
+                                                 label);
+    Initialize();
+  }
+
+  if (handler_)
+    handler_->OnInitialized(this, succeeded);
+}
+
+media_stream::MediaStreamType FromPepperDeviceType(PP_DeviceType_Dev type) {
+  switch (type) {
+    case PP_DEVICETYPE_DEV_INVALID:
+      return media_stream::kNoService;
+    case PP_DEVICETYPE_DEV_AUDIOCAPTURE:
+      return media_stream::kAudioCapture;
+    case PP_DEVICETYPE_DEV_VIDEOCAPTURE:
+      return media_stream::kVideoCapture;
+    default:
+      NOTREACHED();
+      return media_stream::kNoService;
+  }
+}
+
+PP_DeviceType_Dev FromMediaStreamType(media_stream::MediaStreamType type) {
+  switch (type) {
+    case media_stream::kNoService:
+      return PP_DEVICETYPE_DEV_INVALID;
+    case media_stream::kAudioCapture:
+      return PP_DEVICETYPE_DEV_AUDIOCAPTURE;
+    case media_stream::kVideoCapture:
+      return PP_DEVICETYPE_DEV_VIDEOCAPTURE;
+    default:
+      NOTREACHED();
+      return PP_DEVICETYPE_DEV_INVALID;
+  }
+}
+
+ppapi::DeviceRefData FromStreamDeviceInfo(
+    const media_stream::StreamDeviceInfo& info) {
+  ppapi::DeviceRefData data;
+  data.id = info.device_id;
+  data.name = info.name;
+  data.type = FromMediaStreamType(info.stream_type);
+  return data;
+}
 
 }  // namespace
 
 BrokerDispatcherWrapper::BrokerDispatcherWrapper() {
 }
 
 BrokerDispatcherWrapper::~BrokerDispatcherWrapper() {
 }
 
 bool BrokerDispatcherWrapper::Init(
@@ skipping 181 matching lines @@
   }
 
   // TOOD(ddorwin): Change the IPC to asynchronous: Queue an object containing
   // client and plugin_socket.release(), then return.
   // That message handler will then call client->BrokerConnected() with the
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(ppapi::PlatformFileToInt(plugin_handle), result);
 }
 
+class PepperPluginDelegateImpl::DeviceEnumerationEventHandler
+    : public MediaStreamDispatcherEventHandler {
+ public:
+  DeviceEnumerationEventHandler() {
+  }
+
+  virtual ~DeviceEnumerationEventHandler() {
+    DCHECK(enumerate_callbacks_.empty());
+    DCHECK(open_callbacks_.empty());
+  }
+
+  int RegisterEnumerateDevicesCallback(
+      const EnumerateDevicesCallback& callback) {
+    enumerate_callbacks_[next_id_] = callback;
+    return next_id_++;
+  }
+
+  int RegisterOpenDeviceCallback(const OpenDeviceCallback& callback) {
+    open_callbacks_[next_id_] = callback;
+    return next_id_++;
+  }
+
+  // MediaStreamDispatcherEventHandler implementation.
+  virtual void OnStreamGenerated(
+      int request_id,
+      const std::string& label,
+      const media_stream::StreamDeviceInfoArray& audio_device_array,
+      const media_stream::StreamDeviceInfoArray& video_device_array) OVERRIDE {
+  }
+
+  virtual void OnStreamGenerationFailed(int request_id) OVERRIDE {
+  }
+
+  virtual void OnVideoDeviceFailed(const std::string& label,
+                                   int index) OVERRIDE {
+  }
+
+  virtual void OnAudioDeviceFailed(const std::string& label,
+                                   int index) OVERRIDE {
+  }
+
+  virtual void OnDevicesEnumerated(
+      int request_id,
+      const media_stream::StreamDeviceInfoArray& device_array) OVERRIDE {
+    NotifyDevicesEnumerated(request_id, true, device_array);
+  }
+
+  virtual void OnDevicesEnumerationFailed(int request_id) OVERRIDE {
+    NotifyDevicesEnumerated(request_id, false,
+                            media_stream::StreamDeviceInfoArray());
+  }
+
+  virtual void OnDeviceOpened(
+      int request_id,
+      const std::string& label,
+      const media_stream::StreamDeviceInfo& device_info) OVERRIDE {
+    NotifyDeviceOpened(request_id, true, label);
+  }
+
+  virtual void OnDeviceOpenFailed(int request_id) OVERRIDE {
+    NotifyDeviceOpened(request_id, false, "");
+  }
+
+ private:
+  void NotifyDevicesEnumerated(
+      int request_id,
+      bool succeeded,
+      const media_stream::StreamDeviceInfoArray& device_array) {
+    EnumerateCallbackMap::iterator iter = enumerate_callbacks_.find(request_id);
+    if (iter == enumerate_callbacks_.end()) {
+      NOTREACHED();
+      return;
+    }
+
+    EnumerateDevicesCallback callback = iter->second;
+    enumerate_callbacks_.erase(iter);
+
+    std::vector<ppapi::DeviceRefData> devices;
+    if (succeeded) {
+      devices.reserve(device_array.size());
+      for (media_stream::StreamDeviceInfoArray::const_iterator info =
+               device_array.begin(); info != device_array.end(); ++info) {
+        devices.push_back(FromStreamDeviceInfo(*info));
+      }
+    }
+    callback.Run(request_id, succeeded, devices);
+  }
+
+  void NotifyDeviceOpened(int request_id,
+                          bool succeeded,
+                          const std::string& label) {
+    OpenCallbackMap::iterator iter = open_callbacks_.find(request_id);
+    if (iter == open_callbacks_.end()) {
+      NOTREACHED();
+      return;
+    }
+
+    OpenDeviceCallback callback = iter->second;
+    open_callbacks_.erase(iter);
+
+    callback.Run(request_id, succeeded, label);
+  }
+
+  static int next_id_;

[viettrungluu, 2012/01/27 18:54:34]

Why does this need to be static?

[yzshen1, 2012/01/27 19:20:40]

You are right. It doesn't need to be. Changed.

On 2012/01/27 18:54:34, viettrungluu wrote:

+
+  typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap;
+  EnumerateCallbackMap enumerate_callbacks_;
+
+  typedef std::map<int, OpenDeviceCallback> OpenCallbackMap;
+  OpenCallbackMap open_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceEnumerationEventHandler);
+};
+
+int PepperPluginDelegateImpl::DeviceEnumerationEventHandler::next_id_ = 1;
+
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderViewImpl* render_view)
     : content::RenderViewObserver(render_view),
       render_view_(render_view),
       has_saved_context_menu_action_(false),
       saved_context_menu_action_(0),
       focused_plugin_(NULL),
       mouse_lock_owner_(NULL),
       mouse_locked_(false),
       pending_lock_request_(false),
       pending_unlock_request_(false),
-      last_mouse_event_target_(NULL) {
+      last_mouse_event_target_(NULL),
+      device_enumeration_event_handler_(new DeviceEnumerationEventHandler()) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
   DCHECK(!mouse_lock_owner_);
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
@@ skipping 353 matching lines @@
   if (!render_view_->webkit_preferences().accelerated_plugins_enabled)
     return NULL;
   return new PlatformContext3DImpl(this);
 #else
   return NULL;
 #endif
 }
 
 webkit::ppapi::PluginDelegate::PlatformVideoCapture*
 PepperPluginDelegateImpl::CreateVideoCapture(
-      media::VideoCapture::EventHandler* handler) {
-  return new PlatformVideoCaptureImpl(handler);
+    const std::string& device_id,
+    PlatformVideoCaptureEventHandler* handler) {
+  return new PlatformVideoCaptureImpl(AsWeakPtr(), device_id, handler);
 }
 
 webkit::ppapi::PluginDelegate::PlatformVideoDecoder*
 PepperPluginDelegateImpl::CreateVideoDecoder(
     media::VideoDecodeAccelerator::Client* client,
     int32 command_buffer_route_id) {
   return new PlatformVideoDecoderImpl(client, command_buffer_route_id);
 }
 
 void PepperPluginDelegateImpl::NumberOfFindResultsChanged(int identifier,
@@ skipping 794 matching lines @@
 void PepperPluginDelegateImpl::SampleGamepads(WebKit::WebGamepads* data) {
   if (!gamepad_shared_memory_reader_.get())
     gamepad_shared_memory_reader_.reset(new content::GamepadSharedMemoryReader);
   gamepad_shared_memory_reader_->SampleGamepads(*data);
 }
 
 bool PepperPluginDelegateImpl::IsPageVisible() const {
   return !render_view_->is_hidden();
 }
 
+int PepperPluginDelegateImpl::EnumerateDevices(
+    PP_DeviceType_Dev type,
+    const EnumerateDevicesCallback& callback) {
+  int request_id =
+      device_enumeration_event_handler_->RegisterEnumerateDevicesCallback(
+          callback);
+  render_view_->media_stream_dispatcher()->EnumerateDevices(
+      request_id, device_enumeration_event_handler_.get(),
+      FromPepperDeviceType(type), "");
+  return request_id;
+}
+
 bool PepperPluginDelegateImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PepperPluginDelegateImpl, message)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
                         OnTCPSocketConnectACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                         OnTCPSocketSSLHandshakeACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnTCPSocketReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnTCPSocketWriteACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_BindACK, OnUDPSocketBindACK)
@@ skipping 81 matching lines @@
   webkit::ppapi::PPB_UDPSocket_Private_Impl* socket =
       udp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnSendToCompleted(succeeded, bytes_written);
 }
 
 int PepperPluginDelegateImpl::GetRoutingId() const {
   return render_view_->routing_id();
 }
 
+int PepperPluginDelegateImpl::OpenDevice(PP_DeviceType_Dev type,
+                                         const std::string& device_id,
+                                         const OpenDeviceCallback& callback) {
+  int request_id =
+      device_enumeration_event_handler_->RegisterOpenDeviceCallback(callback);
+  render_view_->media_stream_dispatcher()->OpenDevice(
+      request_id, device_enumeration_event_handler_.get(), device_id,
+      FromPepperDeviceType(type), "");
+  return request_id;
+}
+
+void PepperPluginDelegateImpl::CloseDevice(const std::string& label) {
+  render_view_->media_stream_dispatcher()->CloseDevice(label);
+}
+
+int PepperPluginDelegateImpl::GetSessionID(PP_DeviceType_Dev type,
+                                           const std::string& label) {
+  switch (type) {
+    case PP_DEVICETYPE_DEV_AUDIOCAPTURE:
+      return render_view_->media_stream_dispatcher()->audio_session_id(label,
+                                                                       0);
+    case PP_DEVICETYPE_DEV_VIDEOCAPTURE:
+      return render_view_->media_stream_dispatcher()->video_session_id(label,
+                                                                       0);
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 RendererGLContext*
 PepperPluginDelegateImpl::GetParentContextForPlatformContext3D() {
   WebGraphicsContext3DCommandBufferImpl* context =
       static_cast<WebGraphicsContext3DCommandBufferImpl*>(
           render_view_->webview()->graphicsContext3D());
   if (!context)
     return NULL;
   if (!context->makeContextCurrent() || context->isContextLost())
     return NULL;
 
   RendererGLContext* parent_context = context->context();
   if (!parent_context)
     return NULL;
   return parent_context;
 }
 
 bool PepperPluginDelegateImpl::CanUseSocketAPIs() {
   WebView* webview = render_view_->webview();
   WebFrame* main_frame = webview ? webview->mainFrame() : NULL;
   GURL url(main_frame ? GURL(main_frame->document().url()) : GURL());
   if (!url.is_valid())
     return false;
 
   return content::GetContentClient()->renderer()->AllowSocketAPI(url);
 }