ppapi/cpp/instance.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/cpp/instance.h"
   6
   7 #include "ppapi/c/pp_errors.h"
   8 #include "ppapi/c/ppb_console.h"
   9 #include "ppapi/c/ppb_input_event.h"
  10 #include "ppapi/c/ppb_instance.h"
  11 #include "ppapi/c/ppb_messaging.h"
  12 #include "ppapi/c/ppp_message_handler.h"
  13 #include "ppapi/cpp/compositor.h"
  14 #include "ppapi/cpp/graphics_2d.h"
  15 #include "ppapi/cpp/graphics_3d.h"
  16 #include "ppapi/cpp/image_data.h"
  17 #include "ppapi/cpp/instance_handle.h"
  18 #include "ppapi/cpp/logging.h"
  19 #include "ppapi/cpp/message_handler.h"
  20 #include "ppapi/cpp/message_loop.h"
  21 #include "ppapi/cpp/module.h"
  22 #include "ppapi/cpp/module_impl.h"
  23 #include "ppapi/cpp/point.h"
  24 #include "ppapi/cpp/resource.h"
  25 #include "ppapi/cpp/var.h"
  26 #include "ppapi/cpp/view.h"
  27
  28 namespace pp {
  29
  30 namespace {
  31
  32 template <> const char* interface_name<PPB_Console_1_0>() {
  33   return PPB_CONSOLE_INTERFACE_1_0;
  34 }
  35
  36 template <> const char* interface_name<PPB_InputEvent_1_0>() {
  37   return PPB_INPUT_EVENT_INTERFACE_1_0;
  38 }
  39
  40 template <> const char* interface_name<PPB_Instance_1_0>() {
  41   return PPB_INSTANCE_INTERFACE_1_0;
  42 }
  43
  44 template <> const char* interface_name<PPB_Messaging_1_0>() {
  45   return PPB_MESSAGING_INTERFACE_1_0;
  46 }
  47
  48 template <> const char* interface_name<PPB_Messaging_1_2>() {
  49   return PPB_MESSAGING_INTERFACE_1_2;
  50 }
  51
  52 // PPP_MessageHandler implementation -------------------------------------------
  53 void HandleMessage(PP_Instance pp_instance,
  54                    void* user_data,
  55                    const PP_Var* var) {
  56   MessageHandler* message_handler = static_cast<MessageHandler*>(user_data);
  57   message_handler->HandleMessage(InstanceHandle(pp_instance), Var(*var));
  58 }
  59
  60 void HandleBlockingMessage(PP_Instance pp_instance,
  61                            void* user_data,
  62                            const PP_Var* var,
  63                            PP_Var* result) {
  64   MessageHandler* message_handler = static_cast<MessageHandler*>(user_data);
  65   pp::Var result_var =
  66       message_handler->HandleBlockingMessage(InstanceHandle(pp_instance),
  67                                              Var(*var));
  68   *result = result_var.Detach();
  69 }
  70
  71 void Destroy(PP_Instance pp_instance, void* user_data) {
  72   MessageHandler* message_handler = static_cast<MessageHandler*>(user_data);
  73   message_handler->WasUnregistered(InstanceHandle(pp_instance));
  74 }
  75
  76 static PPP_MessageHandler_0_2 message_handler_if = {
  77   &HandleMessage, &HandleBlockingMessage, &Destroy
  78 };
  79
  80 }  // namespace
  81
  82 Instance::Instance(PP_Instance instance) : pp_instance_(instance) {
  83 }
  84
  85 Instance::~Instance() {
  86 }
  87
  88 bool Instance::Init(uint32_t /*argc*/, const char* /*argn*/[],
  89                     const char* /*argv*/[]) {
  90   return true;
  91 }
  92
  93 void Instance::DidChangeView(const View& view) {
  94   // Call the deprecated version for source backwards-compat.
  95   DidChangeView(view.GetRect(), view.GetClipRect());
  96 }
  97
  98 void Instance::DidChangeView(const pp::Rect& /*position*/,
  99                              const pp::Rect& /*clip*/) {
 100 }
 101
 102 void Instance::DidChangeFocus(bool /*has_focus*/) {
 103 }
 104
 105
 106 bool Instance::HandleDocumentLoad(const URLLoader& /*url_loader*/) {
 107   return false;
 108 }
 109
 110 bool Instance::HandleInputEvent(const InputEvent& /*event*/) {
 111   return false;
 112 }
 113
 114 void Instance::HandleMessage(const Var& /*message*/) {
 115   return;
 116 }
 117
 118 bool Instance::BindGraphics(const Graphics2D& graphics) {
 119   if (!has_interface<PPB_Instance_1_0>())
 120     return false;
 121   return PP_ToBool(get_interface<PPB_Instance_1_0>()->BindGraphics(
 122       pp_instance(), graphics.pp_resource()));
 123 }
 124
 125 bool Instance::BindGraphics(const Graphics3D& graphics) {
 126   if (!has_interface<PPB_Instance_1_0>())
 127     return false;
 128   return PP_ToBool(get_interface<PPB_Instance_1_0>()->BindGraphics(
 129       pp_instance(), graphics.pp_resource()));
 130 }
 131
 132 bool Instance::BindGraphics(const Compositor& compositor) {
 133   if (!has_interface<PPB_Instance_1_0>())
 134     return false;
 135   return PP_ToBool(get_interface<PPB_Instance_1_0>()->BindGraphics(
 136       pp_instance(), compositor.pp_resource()));
 137 }
 138
 139 bool Instance::IsFullFrame() {
 140   if (!has_interface<PPB_Instance_1_0>())
 141     return false;
 142   return PP_ToBool(get_interface<PPB_Instance_1_0>()->IsFullFrame(
 143       pp_instance()));
 144 }
 145
 146 int32_t Instance::RequestInputEvents(uint32_t event_classes) {
 147   if (!has_interface<PPB_InputEvent_1_0>())
 148     return PP_ERROR_NOINTERFACE;
 149   return get_interface<PPB_InputEvent_1_0>()->RequestInputEvents(pp_instance(),
 150                                                                  event_classes);
 151 }
 152
 153 int32_t Instance::RequestFilteringInputEvents(uint32_t event_classes) {
 154   if (!has_interface<PPB_InputEvent_1_0>())
 155     return PP_ERROR_NOINTERFACE;
 156   return get_interface<PPB_InputEvent_1_0>()->RequestFilteringInputEvents(
 157       pp_instance(), event_classes);
 158 }
 159
 160 void Instance::ClearInputEventRequest(uint32_t event_classes) {
 161   if (!has_interface<PPB_InputEvent_1_0>())
 162     return;
 163   get_interface<PPB_InputEvent_1_0>()->ClearInputEventRequest(pp_instance(),
 164                                                           event_classes);
 165 }
 166
 167 void Instance::PostMessage(const Var& message) {
 168   if (has_interface<PPB_Messaging_1_2>()) {
 169     get_interface<PPB_Messaging_1_2>()->PostMessage(pp_instance(),
 170                                                     message.pp_var());
 171   } else if (has_interface<PPB_Messaging_1_0>()) {
 172     get_interface<PPB_Messaging_1_0>()->PostMessage(pp_instance(),
 173                                                     message.pp_var());
 174   }
 175 }
 176
 177 int32_t Instance::RegisterMessageHandler(MessageHandler* message_handler,
 178                                          const MessageLoop& message_loop) {
 179   if (!has_interface<PPB_Messaging_1_2>())
 180     return PP_ERROR_NOTSUPPORTED;
 181   return get_interface<PPB_Messaging_1_2>()->RegisterMessageHandler(
 182       pp_instance(),
 183       message_handler,
 184       &message_handler_if,
 185       message_loop.pp_resource());
 186 }
 187
 188 void Instance::UnregisterMessageHandler() {
 189   if (!has_interface<PPB_Messaging_1_2>())
 190     return;
 191   get_interface<PPB_Messaging_1_2>()->UnregisterMessageHandler(pp_instance());
 192 }
 193
 194 void Instance::LogToConsole(PP_LogLevel level, const Var& value) {
 195   if (!has_interface<PPB_Console_1_0>())
 196     return;
 197   get_interface<PPB_Console_1_0>()->Log(
 198       pp_instance(), level, value.pp_var());
 199 }
 200
 201 void Instance::LogToConsoleWithSource(PP_LogLevel level,
 202                                       const Var& source,
 203                                       const Var& value) {
 204   if (!has_interface<PPB_Console_1_0>())
 205     return;
 206   get_interface<PPB_Console_1_0>()->LogWithSource(
 207       pp_instance(), level, source.pp_var(), value.pp_var());
 208 }
 209
 210 void Instance::AddPerInstanceObject(const std::string& interface_name,
 211                                     void* object) {
 212   // Ensure we're not trying to register more than one object per interface
 213   // type. Otherwise, we'll get confused in GetPerInstanceObject.
 214   PP_DCHECK(interface_name_to_objects_.find(interface_name) ==
 215             interface_name_to_objects_.end());
 216   interface_name_to_objects_[interface_name] = object;
 217 }
 218
 219 void Instance::RemovePerInstanceObject(const std::string& interface_name,
 220                                        void* object) {
 221   InterfaceNameToObjectMap::iterator found = interface_name_to_objects_.find(
 222       interface_name);
 223   if (found == interface_name_to_objects_.end()) {
 224     // Attempting to unregister an object that doesn't exist or was already
 225     // unregistered.
 226     PP_DCHECK(false);
 227     return;
 228   }
 229
 230   // Validate that we're removing the object we thing we are.
 231   PP_DCHECK(found->second == object);
 232   (void)object;  // Prevent warning in release mode.
 233
 234   interface_name_to_objects_.erase(found);
 235 }
 236
 237 // static
 238 void Instance::RemovePerInstanceObject(const InstanceHandle& instance,
 239                                        const std::string& interface_name,
 240                                        void* object) {
 241   // TODO(brettw) assert we're on the main thread.
 242   Instance* that = Module::Get()->InstanceForPPInstance(instance.pp_instance());
 243   if (!that)
 244     return;
 245   that->RemovePerInstanceObject(interface_name, object);
 246 }
 247
 248 // static
 249 void* Instance::GetPerInstanceObject(PP_Instance instance,
 250                                      const std::string& interface_name) {
 251   Instance* that = Module::Get()->InstanceForPPInstance(instance);
 252   if (!that)
 253     return NULL;
 254   InterfaceNameToObjectMap::iterator found =
 255       that->interface_name_to_objects_.find(interface_name);
 256   if (found == that->interface_name_to_objects_.end())
 257     return NULL;
 258   return found->second;
 259 }
 260
 261 }  // namespace pp