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/gpu/client/content_gl_context.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.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/common/context_menu_params.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/gamepad_shared_memory_reader.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/pepper_platform_video_decoder_impl.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_capture_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 497 matching lines @@
   virtual void DidGrantStorageQuota(int64 granted_quota) OVERRIDE {
     NOTREACHED();
   }
   virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE {
     callback_.Run(0);
   }
  private:
   PluginCallback callback_;
 };
 
-class PlatformVideoCaptureImpl
-    : public webkit::ppapi::PluginDelegate::PlatformVideoCapture {
- public:
-  PlatformVideoCaptureImpl(media::VideoCapture::EventHandler* handler)
-      : handler_proxy_(new media::VideoCaptureHandlerProxy(
-            handler, base::MessageLoopProxy::current())) {
-    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());
+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;
   }
+}
 
-  // Overrides from media::VideoCapture::EventHandler
-  virtual ~PlatformVideoCaptureImpl() {
-    VideoCaptureImplManager* manager =
-        RenderThreadImpl::current()->video_capture_impl_manager();
-    manager->RemoveDevice(1, handler_proxy_.get());
+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;
   }
+}
 
-  virtual void StartCapture(
-      EventHandler* handler,
-      const VideoCaptureCapability& capability) OVERRIDE {
-    DCHECK(handler == handler_proxy_->proxied());
-    video_capture_->StartCapture(handler_proxy_.get(), capability);
-  }
-
-  virtual void StopCapture(EventHandler* handler) OVERRIDE {
-    DCHECK(handler == handler_proxy_->proxied());
-    video_capture_->StopCapture(handler_proxy_.get());
-  }
-
-  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE {
-    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_;
-};
+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;
+}
 
 class PluginInstanceLockTarget : public MouseLockDispatcher::LockTarget {
  public:
   PluginInstanceLockTarget(webkit::ppapi::PluginInstance* plugin)
       : plugin_(plugin) {}
 
   virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
     plugin_->OnLockMouseACK(succeeded);
   }
 
@@ skipping 205 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() : next_id_(1) {
+  }
+
+  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);
+  }
+
+  int next_id_;
+
+  typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap;
+  EnumerateCallbackMap enumerate_callbacks_;
+
+  typedef std::map<int, OpenDeviceCallback> OpenCallbackMap;
+  OpenCallbackMap open_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceEnumerationEventHandler);
+};
+
 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),
-      last_mouse_event_target_(NULL) {
+      last_mouse_event_target_(NULL),
+      device_enumeration_event_handler_(new DeviceEnumerationEventHandler()) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
   DCHECK(mouse_lock_instances_.empty());
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
@@ skipping 358 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 PepperPlatformVideoCaptureImpl(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 705 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;
+  }
+}
+
 ContentGLContext*
 PepperPluginDelegateImpl::GetParentContextForPlatformContext3D() {
   WebGraphicsContext3DCommandBufferImpl* context =
       static_cast<WebGraphicsContext3DCommandBufferImpl*>(
           render_view_->webview()->graphicsContext3D());
   if (!context)
     return NULL;
   if (!context->makeContextCurrent() || context->isContextLost())
     return NULL;
 
@@ skipping 27 matching lines @@
 void PepperPluginDelegateImpl::UnSetAndDeleteLockTargetAdapter(
     webkit::ppapi::PluginInstance* instance) {
   LockTargetMap::iterator it = mouse_lock_instances_.find(instance);
   if (it != mouse_lock_instances_.end()) {
     MouseLockDispatcher::LockTarget* target = it->second;
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(target);
     delete target;
     mouse_lock_instances_.erase(it);
   }
 }