Add an asynchronous version of the Flash DeviceID API.

ppapi/proxy/ppb_flash_device_id_proxy.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 "ppapi/proxy/ppb_flash_device_id_proxy.h"
+
+#include "base/compiler_specific.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_globals.h"
+#include "ppapi/proxy/plugin_proxy_delegate.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/tracked_callback.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_flash_device_id_api.h"
+
+using ppapi::thunk::PPB_Flash_DeviceID_API;
+
+namespace ppapi {
+namespace proxy {
+
+namespace {
+
+class DeviceID : public Resource, public PPB_Flash_DeviceID_API {
+ public:
+  DeviceID(PP_Instance instance);
+  virtual ~DeviceID();
+
+  // Resource overrides.
+  virtual PPB_Flash_DeviceID_API* AsPPB_Flash_DeviceID_API() OVERRIDE;
+
+  // PPB_Flash_DeviceID_API implementation.
+  virtual int32_t GetDeviceID(PP_Var* id,
+                              const PP_CompletionCallback& callback) OVERRIDE;
+
+  void OnReply(int32_t result, const std::string& id);
+
+ private:
+  // Non-null when a callback is pending.
+  PP_Var* dest_;
+
+  scoped_refptr<TrackedCallback> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceID);
+};
+
+DeviceID::DeviceID(PP_Instance instance)
+    : Resource(OBJECT_IS_PROXY, instance),
+      dest_(NULL) {
+}
+
+DeviceID::~DeviceID() {
+}
+
+PPB_Flash_DeviceID_API* DeviceID::AsPPB_Flash_DeviceID_API() {
+  return this;
+}
+
+int32_t DeviceID::GetDeviceID(PP_Var* id,
+                              const PP_CompletionCallback& callback) {
+  if (TrackedCallback::IsPending(callback_))
+    return PP_ERROR_INPROGRESS;
+  if (!id)
+    return PP_ERROR_BADARGUMENT;
+
+  callback_ = new TrackedCallback(this, callback);
+  dest_ = id;
+
+  PluginDispatcher* dispatcher =
+      PluginDispatcher::GetForInstance(pp_instance());
+
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PpapiHostMsg_PPBFlashDeviceID_Get(
+          API_ID_PPB_FLASH_DEVICE_ID, dispatcher->plugin_dispatcher_id(),
+          pp_resource()));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void DeviceID::OnReply(int32_t result, const std::string& id) {
+  if (result == PP_OK)
+    *dest_ = StringVar::StringToPPVar(id);
+  else
+    *dest_ = PP_MakeUndefined();
+  dest_ = NULL;
+  TrackedCallback::ClearAndRun(&callback_, result);
+}
+
+}  // namespace
+
+PPB_Flash_DeviceID_Proxy::PPB_Flash_DeviceID_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher) {
+}
+
+PPB_Flash_DeviceID_Proxy::~PPB_Flash_DeviceID_Proxy() {
+}
+
+// static
+PP_Resource PPB_Flash_DeviceID_Proxy::CreateProxyResource(
+    PP_Instance instance) {
+  return (new DeviceID(instance))->GetReference();
+}
+
+bool PPB_Flash_DeviceID_Proxy::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PPB_Flash_DeviceID_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashDeviceID_GetReply,
+                        OnPluginMsgGetReply)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PPB_Flash_DeviceID_Proxy::OnPluginMsgGetReply(int32 routing_id,
+                                                   PP_Resource resource,
+                                                   int32 result,
+                                                   const std::string& id) {
+  thunk::EnterResourceNoLock<PPB_Flash_DeviceID_API> enter(resource, false);
+  if (enter.failed())
+    return;  // Resource destroyed.
+  static_cast<DeviceID*>(enter.object())->OnReply(result, id);
+}
+
+}  // namespace proxy
+}  // namespace ppapi