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::EnumerateDevices(
  40     const PP_ArrayOutput& output,
  41     scoped_refptr<TrackedCallback> callback) {
  42   if (pending_enumerate_devices_)
  43     return PP_ERROR_INPROGRESS;
  44
  45   pending_enumerate_devices_ = true;
  46   PpapiHostMsg_DeviceEnumeration_EnumerateDevices msg;
  47   owner_->Call<PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply>(
  48       PluginResource::RENDERER, msg,
  49       base::Bind(
  50           &DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply,
  51           AsWeakPtr(), output, callback));
  52   return PP_OK_COMPLETIONPENDING;
  53 }
  54
  55 int32_t DeviceEnumerationResourceHelper::EnumerateDevicesSync(
  56     const PP_ArrayOutput& output) {
  57   std::vector<DeviceRefData> devices;
  58   int32_t result =
  59       owner_->SyncCall<PpapiPluginMsg_DeviceEnumeration_EnumerateDevicesReply>(
  60           PluginResource::RENDERER,
  61           PpapiHostMsg_DeviceEnumeration_EnumerateDevices(),
  62           &devices);
  63
  64   if (result == PP_OK)
  65     result = WriteToArrayOutput(devices, output);
  66
  67   return result;
  68 }
  69
  70 int32_t DeviceEnumerationResourceHelper::MonitorDeviceChange(
  71     PP_MonitorDeviceChangeCallback callback,
  72     void* user_data) {
  73   monitor_callback_id_++;
  74   monitor_user_data_ = user_data;
  75   if (callback) {
  76     monitor_callback_.reset(
  77         ThreadAwareCallback<PP_MonitorDeviceChangeCallback>::Create(callback));
  78     if (!monitor_callback_.get())
  79       return PP_ERROR_NO_MESSAGE_LOOP;
  80
  81     owner_->Post(PluginResource::RENDERER,
  82                  PpapiHostMsg_DeviceEnumeration_MonitorDeviceChange(
  83                      monitor_callback_id_));
  84   } else {
  85     monitor_callback_.reset(NULL);
  86
  87     owner_->Post(PluginResource::RENDERER,
  88                  PpapiHostMsg_DeviceEnumeration_StopMonitoringDeviceChange());
  89   }
  90   return PP_OK;
  91 }
  92
  93 bool DeviceEnumerationResourceHelper::HandleReply(
  94     const ResourceMessageReplyParams& params,
  95     const IPC::Message& msg) {
  96   PPAPI_BEGIN_MESSAGE_MAP(DeviceEnumerationResourceHelper, msg)
  97     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
  98         PpapiPluginMsg_DeviceEnumeration_NotifyDeviceChange,
  99         OnPluginMsgNotifyDeviceChange)
 100     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(return false)
 101   PPAPI_END_MESSAGE_MAP()
 102
 103   return true;
 104 }
 105
 106 void DeviceEnumerationResourceHelper::LastPluginRefWasDeleted() {
 107   // Make sure that no further notifications are sent to the plugin.
 108   monitor_callback_id_++;
 109   monitor_callback_.reset(NULL);
 110   monitor_user_data_ = NULL;
 111
 112   // There is no need to do anything with pending callback of
 113   // EnumerateDevices(), because OnPluginMsgEnumerateDevicesReply*() will handle
 114   // that properly.
 115 }
 116
 117 void DeviceEnumerationResourceHelper::OnPluginMsgEnumerateDevicesReply(
 118     const PP_ArrayOutput& output,
 119     scoped_refptr<TrackedCallback> callback,
 120     const ResourceMessageReplyParams& params,
 121     const std::vector<DeviceRefData>& devices) {
 122   pending_enumerate_devices_ = false;
 123
 124   // We shouldn't access |output| if the callback has been called, which is
 125   // possible if the last plugin reference to the corresponding resource has
 126   // gone away, and the callback has been aborted.
 127   if (!TrackedCallback::IsPending(callback))
 128     return;
 129
 130   int32_t result = params.result();
 131   if (result == PP_OK)
 132     result = WriteToArrayOutput(devices, output);
 133
 134   callback->Run(result);
 135 }
 136
 137 void DeviceEnumerationResourceHelper::OnPluginMsgNotifyDeviceChange(
 138     const ResourceMessageReplyParams& /* params */,
 139     uint32_t callback_id,
 140     const std::vector<DeviceRefData>& devices) {
 141   if (monitor_callback_id_ != callback_id) {
 142     // A new callback or NULL has been set.
 143     return;
 144   }
 145
 146   CHECK(monitor_callback_.get());
 147
 148   scoped_ptr<PP_Resource[]> elements;
 149   uint32_t size = devices.size();
 150   if (size > 0) {
 151     elements.reset(new PP_Resource[size]);
 152     for (size_t index = 0; index < size; ++index) {
 153       PPB_DeviceRef_Shared* device_object = new PPB_DeviceRef_Shared(
 154           OBJECT_IS_PROXY, owner_->pp_instance(), devices[index]);
 155       elements[index] = device_object->GetReference();
 156     }
 157   }
 158
 159   monitor_callback_->RunOnTargetThread(monitor_user_data_, size,
 160                                        elements.get());
 161   for (size_t index = 0; index < size; ++index)
 162     PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(elements[index]);
 163 }
 164
 165 int32_t DeviceEnumerationResourceHelper::WriteToArrayOutput(
 166     const std::vector<DeviceRefData>& devices,
 167     const PP_ArrayOutput& output) {
 168   ArrayWriter writer(output);
 169   if (!writer.is_valid())
 170     return PP_ERROR_BADARGUMENT;
 171
 172   std::vector<scoped_refptr<Resource> > device_resources;
 173   for (size_t i = 0; i < devices.size(); ++i) {
 174     device_resources.push_back(new PPB_DeviceRef_Shared(
 175         OBJECT_IS_PROXY, owner_->pp_instance(), devices[i]));
 176   }
 177   if (!writer.StoreResourceVector(device_resources))
 178     return PP_ERROR_FAILED;
 179
 180   return PP_OK;
 181 }
 182
 183 }  // namespace proxy
 184 }  // namespace ppapi