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