content/renderer/pepper/pepper_device_enumeration_host_helper.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_device_enumeration_host_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/memory/weak_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "ipc/ipc_message.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/host/dispatch_host_message.h"
  14 #include "ppapi/host/host_message_context.h"
  15 #include "ppapi/host/ppapi_host.h"
  16 #include "ppapi/host/resource_host.h"
  17 #include "ppapi/proxy/ppapi_messages.h"
  18 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
  19
  20 using ppapi::host::HostMessageContext;
  21
  22 namespace content {
  23
  24 // Makes sure that StopEnumerateDevices() is called for each EnumerateDevices().
  25 class PepperDeviceEnumerationHostHelper::ScopedRequest
  26     : public base::SupportsWeakPtr<ScopedRequest> {
  27  public:
  28   // |owner| must outlive this object.
  29   ScopedRequest(PepperDeviceEnumerationHostHelper* owner,
  30                 const Delegate::EnumerateDevicesCallback& callback)
  31       : owner_(owner),
  32         callback_(callback),
  33         requested_(false),
  34         request_id_(0),
  35         sync_call_(false) {
  36     if (!owner_->document_url_.is_valid())
  37       return;
  38
  39     requested_ = true;
  40
  41     // Note that the callback passed into
  42     // PepperDeviceEnumerationHostHelper::Delegate::EnumerateDevices() may be
  43     // called synchronously. In that case, |request_id_| hasn't been updated
  44     // when the callback is called. Moreover, |callback| may destroy this
  45     // object. So we don't pass in |callback| directly. Instead, we use
  46     // EnumerateDevicesCallbackBody() to ensure that we always call |callback|
  47     // asynchronously.
  48     sync_call_ = true;
  49     DCHECK(owner_->delegate_);
  50     request_id_ = owner_->delegate_->EnumerateDevices(
  51         owner_->device_type_,
  52         owner_->document_url_,
  53         base::Bind(&ScopedRequest::EnumerateDevicesCallbackBody, AsWeakPtr()));
  54     sync_call_ = false;
  55   }
  56
  57   ~ScopedRequest() {
  58     if (requested_ && owner_->delegate_) {
  59       owner_->delegate_->StopEnumerateDevices(request_id_);
  60     }
  61   }
  62
  63   bool requested() const { return requested_; }
  64
  65  private:
  66   void EnumerateDevicesCallbackBody(
  67       int request_id,
  68       const std::vector<ppapi::DeviceRefData>& devices) {
  69     if (sync_call_) {
  70       base::MessageLoop::current()->PostTask(
  71           FROM_HERE,
  72           base::Bind(&ScopedRequest::EnumerateDevicesCallbackBody,
  73                      AsWeakPtr(),
  74                      request_id,
  75                      devices));
  76     } else {
  77       DCHECK_EQ(request_id_, request_id);
  78       callback_.Run(request_id, devices);
  79       // This object may have been destroyed at this point.
  80     }
  81   }
  82
  83   PepperDeviceEnumerationHostHelper* owner_;
  84   PepperDeviceEnumerationHostHelper::Delegate::EnumerateDevicesCallback
  85       callback_;
  86   bool requested_;
  87   int request_id_;
  88   bool sync_call_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(ScopedRequest);
  91 };
  92
  93 PepperDeviceEnumerationHostHelper::PepperDeviceEnumerationHostHelper(
  94     ppapi::host::ResourceHost* resource_host,
  95     base::WeakPtr<Delegate> delegate,
  96     PP_DeviceType_Dev device_type,
  97     const GURL& document_url)
  98     : resource_host_(resource_host),
  99       delegate_(delegate),
 100       device_type_(device_type),
 101       document_url_(document_url) {}
 102
 103 PepperDeviceEnumerationHostHelper::~PepperDeviceEnumerationHostHelper() {}
 104
 105 bool PepperDeviceEnumerationHostHelper::HandleResourceMessage(
 106     const IPC::Message& msg,
 107     HostMessageContext* context,
 108     int32_t* result) {
 109   bool return_value = false;
 110   *result = InternalHandleResourceMessage(msg, context, &return_value);
 111   return return_value;
 112 }
 113
 114 int32_t PepperDeviceEnumerationHostHelper::InternalHandleResourceMessage(
 115     const IPC::Message& msg,
 116     HostMessageContext* context,
 117     bool* handled) {
 118   *handled = true;
 119   PPAPI_BEGIN_MESSAGE_MAP(PepperDeviceEnumerationHostHelper, msg)
 120     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
 121         PpapiHostMsg_DeviceEnumeration_EnumerateDevices, OnEnumerateDevices)
 122     PPAPI_DISPATCH_HOST_RESOURCE_CALL(
 123         PpapiHostMsg_DeviceEnumeration_MonitorDeviceChange,
 124         OnMonitorDeviceChange)
 125     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
 126         PpapiHostMsg_DeviceEnumeration_StopMonitoringDeviceChange,
 127         OnStopMonitoringDeviceChange)
 128   PPAPI_END_MESSAGE_MAP()
 129
 130   *handled = false;
 131   return PP_ERROR_FAILED;
 132 }
 133
 134 int32_t PepperDeviceEnumerationHostHelper::OnEnumerateDevices(
 135     HostMessageContext* context) {
 136   if (enumerate_devices_context_.is_valid())
 137     return PP_ERROR_INPROGRESS;
 138
 139   enumerate_.reset(new ScopedRequest(
 140       this,
 141       base::Bind(&PepperDeviceEnumerationHostHelper::OnEnumerateDevicesComplete,
 142                  base::Unretained(this))));
 143   if (!enumerate_->requested())
 144     return PP_ERROR_FAILED;
 145
 146   enumerate_devices_context_ = context->MakeReplyMessageContext();
 147   return PP_OK_COMPLETIONPENDING;
 148 }
 149
 150 int32_t PepperDeviceEnumerationHostHelper::OnMonitorDeviceChange(
 151     HostMessageContext* /* context */,
 152     uint32_t callback_id) {
 153   monitor_.reset(new ScopedRequest(
 154       this,
 155       base::Bind(&PepperDeviceEnumerationHostHelper::OnNotifyDeviceChange,
 156                  base::Unretained(this),
 157                  callback_id)));
 158
 159   return monitor_->requested() ? PP_OK : PP_ERROR_FAILED;
 160 }
 161
 162 int32_t PepperDeviceEnumerationHostHelper::OnStopMonitoringDeviceChange(
 163     HostMessageContext* /* context */) {
 164   monitor_.reset(NULL);
 165   return PP_OK;
 166 }
 167
 168 void PepperDeviceEnumerationHostHelper::OnEnumerateDevicesComplete(
 169     int /* request_id */,
 170     const std::vector<ppapi::DeviceRefData>& devices) {
 171   DCHECK(enumerate_devices_context_.is_valid());
 172
 173   enumerate_.reset(NULL);
 174
 175   enumerate_devices_context_.params.set_result(PP_OK);
 176   resource_host_->host()->SendReply(
 177       enumerate_devices_context_,
 178       PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply(devices));
 179   enumerate_devices_context_ = ppapi::host::ReplyMessageContext();
 180 }
 181
 182 void PepperDeviceEnumerationHostHelper::OnNotifyDeviceChange(
 183     uint32_t callback_id,
 184     int /* request_id */,
 185     const std::vector<ppapi::DeviceRefData>& devices) {
 186   resource_host_->host()->SendUnsolicitedReply(
 187       resource_host_->pp_resource(),
 188       PpapiPluginMsg_DeviceEnumeration_NotifyDeviceChange(callback_id,
 189                                                           devices));
 190 }
 191
 192 }  // namespace content