src/ppapi/proxy/device_enumeration_resource_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 "ppapi/proxy/device_enumeration_resource_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "ipc/ipc_message.h"
  11 #include "ipc/ipc_message_macros.h"
  12 #include "ppapi/c/pp_array_output.h"
  13 #include "ppapi/c/pp_errors.h"
  14 #include "ppapi/proxy/dispatch_reply_message.h"
  15 #include "ppapi/proxy/plugin_resource.h"
  16 #include "ppapi/proxy/ppapi_messages.h"
  17 #include "ppapi/proxy/resource_message_params.h"
  18 #include "ppapi/shared_impl/array_writer.h"
  19 #include "ppapi/shared_impl/ppapi_globals.h"
  20 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
  21 #include "ppapi/shared_impl/proxy_lock.h"
  22 #include "ppapi/shared_impl/resource_tracker.h"
  23 #include "ppapi/shared_impl/tracked_callback.h"
  24
  25 namespace ppapi {
  26 namespace proxy {
  27
  28 DeviceEnumerationResourceHelper::DeviceEnumerationResourceHelper(
  29     PluginResource* owner)
  30     : owner_(owner),
  31       pending_enumerate_devices_(false),
  32       monitor_callback_id_(0),
  33       monitor_user_data_(NULL) {
  34 }
  35
  36 DeviceEnumerationResourceHelper::~DeviceEnumerationResourceHelper() {
  37 }
  38
  39 int32_t DeviceEnumerationResourceHelper::EnumerateDevices0_2(
  40     PP_Resource* devices,
  41     scoped_refptr<TrackedCallback> callback) {
  42   if (pending_enumerate_devices_)
  43     return PP_ERROR_INPROGRESS;
  44   if (!devices)
  45     return PP_ERROR_BADARGUMENT;
  46
  47   pending_enumerate_devices_ = true;
  48   PpapiHostMsg_DeviceEnumeration_EnumerateDevices msg;
  49   owner_->Call<PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply>(
  50       PluginResource::RENDERER, msg,
  51       base::Bind(
  52           &DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply0_2,
  53           AsWeakPtr(), devices, callback));
  54   return PP_OK_COMPLETIONPENDING;
  55 }
  56
  57 int32_t DeviceEnumerationResourceHelper::EnumerateDevices(
  58     const PP_ArrayOutput& output,
  59     scoped_refptr<TrackedCallback> callback) {
  60   if (pending_enumerate_devices_)
  61     return PP_ERROR_INPROGRESS;
  62
  63   pending_enumerate_devices_ = true;
  64   PpapiHostMsg_DeviceEnumeration_EnumerateDevices msg;
  65   owner_->Call<PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply>(
  66       PluginResource::RENDERER, msg,
  67       base::Bind(
  68           &DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply,
  69           AsWeakPtr(), output, callback));
  70   return PP_OK_COMPLETIONPENDING;
  71 }
  72
  73 int32_t DeviceEnumerationResourceHelper::EnumerateDevicesSync(
  74     const PP_ArrayOutput& output) {
  75   std::vector<DeviceRefData> devices;
  76   int32_t result =
  77       owner_->SyncCall<PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply>(
  78           PluginResource::RENDERER,
  79           PpapiHostMsg_DeviceEnumeration_EnumerateDevices(),
  80           &devices);
  81
  82   if (result == PP_OK)
  83     result = WriteToArrayOutput(devices, output);
  84
  85   return result;
  86 }
  87
  88 int32_t DeviceEnumerationResourceHelper::MonitorDeviceChange(
  89     PP_MonitorDeviceChangeCallback callback,
  90     void* user_data) {
  91   monitor_callback_id_++;
  92   monitor_user_data_ = user_data;
  93   if (callback) {
  94     monitor_callback_.reset(
  95         ThreadAwareCallback<PP_MonitorDeviceChangeCallback>::Create(callback));
  96     if (!monitor_callback_.get())
  97       return PP_ERROR_NO_MESSAGE_LOOP;
  98
  99     owner_->Post(PluginResource::RENDERER,
 100                  PpapiHostMsg_DeviceEnumeration_MonitorDeviceChange(
 101                      monitor_callback_id_));
 102   } else {
 103     monitor_callback_.reset(NULL);
 104
 105     owner_->Post(PluginResource::RENDERER,
 106                  PpapiHostMsg_DeviceEnumeration_StopMonitoringDeviceChange());
 107   }
 108   return PP_OK;
 109 }
 110
 111 bool DeviceEnumerationResourceHelper::HandleReply(
 112     const ResourceMessageReplyParams& params,
 113     const IPC::Message& msg) {
 114   IPC_BEGIN_MESSAGE_MAP(DeviceEnumerationResourceHelper, msg)
 115     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 116         PpapiPluginMsg_DeviceEnumeration_NotifyDeviceChange,
 117         OnPluginMsgNotifyDeviceChange)
 118     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(return false)
 119   IPC_END_MESSAGE_MAP()
 120
 121   return true;
 122 }
 123
 124 void DeviceEnumerationResourceHelper::LastPluginRefWasDeleted() {
 125   // Make sure that no further notifications are sent to the plugin.
 126   monitor_callback_id_++;
 127   monitor_callback_.reset(NULL);
 128   monitor_user_data_ = NULL;
 129
 130   // There is no need to do anything with pending callback of
 131   // EnumerateDevices(), because OnPluginMsgEnumerateDevicesReply*() will handle
 132   // that properly.
 133 }
 134
 135 void DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply0_2(
 136     PP_Resource* devices_resource,
 137     scoped_refptr<TrackedCallback> callback,
 138     const ResourceMessageReplyParams& params,
 139     const std::vector<DeviceRefData>& devices) {
 140   pending_enumerate_devices_ = false;
 141
 142   // We shouldn't access |devices_resource| if the callback has been called,
 143   // which is possible if the last plugin reference to the corresponding
 144   // resource has gone away, and the callback has been aborted.
 145   if (!TrackedCallback::IsPending(callback))
 146     return;
 147
 148   if (params.result() == PP_OK) {
 149     *devices_resource = PPB_DeviceRef_Shared::CreateResourceArray(
 150         OBJECT_IS_PROXY, owner_->pp_instance(), devices);
 151   }
 152
 153   callback->Run(params.result());
 154 }
 155
 156 void DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply(
 157     const PP_ArrayOutput& output,
 158     scoped_refptr<TrackedCallback> callback,
 159     const ResourceMessageReplyParams& params,
 160     const std::vector<DeviceRefData>& devices) {
 161   pending_enumerate_devices_ = false;
 162
 163   // We shouldn't access |output| if the callback has been called, which is
 164   // possible if the last plugin reference to the corresponding resource has
 165   // gone away, and the callback has been aborted.
 166   if (!TrackedCallback::IsPending(callback))
 167     return;
 168
 169   int32_t result = params.result();
 170   if (result == PP_OK)
 171     result = WriteToArrayOutput(devices, output);
 172
 173   callback->Run(result);
 174 }
 175
 176 void DeviceEnumerationResourceHelper::OnPluginMsgNotifyDeviceChange(
 177     const ResourceMessageReplyParams& /* params */,
 178     uint32_t callback_id,
 179     const std::vector<DeviceRefData>& devices) {
 180   if (monitor_callback_id_ != callback_id) {
 181     // A new callback or NULL has been set.
 182     return;
 183   }
 184
 185   CHECK(monitor_callback_.get());
 186
 187   scoped_ptr<PP_Resource[]> elements;
 188   uint32_t size = devices.size();
 189   if (size > 0) {
 190     elements.reset(new PP_Resource[size]);
 191     for (size_t index = 0; index < size; ++index) {
 192       PPB_DeviceRef_Shared* device_object = new PPB_DeviceRef_Shared(
 193           OBJECT_IS_PROXY, owner_->pp_instance(), devices[index]);
 194       elements[index] = device_object->GetReference();
 195     }
 196   }
 197
 198   monitor_callback_->RunOnTargetThread(monitor_user_data_, size,
 199                                        elements.get());
 200   for (size_t index = 0; index < size; ++index)
 201     PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(elements[index]);
 202 }
 203
 204 int32_t DeviceEnumerationResourceHelper::WriteToArrayOutput(
 205     const std::vector<DeviceRefData>& devices,
 206     const PP_ArrayOutput& output) {
 207   ArrayWriter writer(output);
 208   if (!writer.is_valid())
 209     return PP_ERROR_BADARGUMENT;
 210
 211   std::vector<scoped_refptr<Resource> > device_resources;
 212   for (size_t i = 0; i < devices.size(); ++i) {
 213     device_resources.push_back(new PPB_DeviceRef_Shared(
 214         OBJECT_IS_PROXY, owner_->pp_instance(), devices[i]));
 215   }
 216   if (!writer.StoreResourceVector(device_resources))
 217     return PP_ERROR_FAILED;
 218
 219   return PP_OK;
 220 }
 221
 222 }  // namespace proxy
 223 }  // namespace ppapi