src/mojo/examples/pepper_container_app/plugin_instance.cc

   1 // Copyright 2014 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 "mojo/examples/pepper_container_app/plugin_instance.h"
   6
   7 #include "base/logging.h"
   8 #include "mojo/examples/pepper_container_app/graphics_3d_resource.h"
   9 #include "mojo/examples/pepper_container_app/mojo_ppapi_globals.h"
  10 #include "ppapi/c/pp_errors.h"
  11 #include "ppapi/c/pp_var.h"
  12 #include "ppapi/c/ppp_graphics_3d.h"
  13 #include "ppapi/c/ppp_instance.h"
  14 #include "ppapi/shared_impl/ppb_view_shared.h"
  15 #include "ppapi/shared_impl/proxy_lock.h"
  16 #include "ppapi/shared_impl/tracked_callback.h"
  17 #include "ppapi/thunk/enter.h"
  18 #include "ppapi/thunk/ppb_graphics_3d_api.h"
  19
  20 namespace mojo {
  21 namespace examples {
  22
  23 PluginInstance::PluginInstance(scoped_refptr<PluginModule> plugin_module)
  24     : pp_instance_(0),
  25       plugin_module_(plugin_module) {
  26   pp_instance_ = MojoPpapiGlobals::Get()->AddInstance(this);
  27 }
  28
  29 PluginInstance::~PluginInstance() {
  30   MojoPpapiGlobals::Get()->InstanceDeleted(pp_instance_);
  31 }
  32
  33 bool PluginInstance::DidCreate() {
  34   ppapi::ProxyAutoUnlock unlock;
  35   const PPP_Instance_1_1* instance_interface =
  36       static_cast<const PPP_Instance_1_1*>(plugin_module_->GetPluginInterface(
  37           PPP_INSTANCE_INTERFACE_1_1));
  38   return !!instance_interface->DidCreate(pp_instance(), 0, NULL, NULL);
  39 }
  40
  41 void PluginInstance::DidDestroy() {
  42   ppapi::ProxyAutoUnlock unlock;
  43   const PPP_Instance_1_1* instance_interface =
  44       static_cast<const PPP_Instance_1_1*>(plugin_module_->GetPluginInterface(
  45           PPP_INSTANCE_INTERFACE_1_1));
  46   instance_interface->DidDestroy(pp_instance());
  47 }
  48
  49 void PluginInstance::DidChangeView(const PP_Rect& bounds) {
  50   ppapi::ViewData view_data;
  51   view_data.rect = bounds;
  52   view_data.is_fullscreen = false;
  53   view_data.is_page_visible = true;
  54   view_data.clip_rect = bounds;
  55   view_data.device_scale = 1.0f;
  56   view_data.css_scale = 1.0f;
  57
  58   ppapi::ScopedPPResource resource(ppapi::ScopedPPResource::PassRef(),
  59       (new ppapi::PPB_View_Shared(
  60           ppapi::OBJECT_IS_IMPL, pp_instance(), view_data))->GetReference());
  61   {
  62     ppapi::ProxyAutoUnlock unlock;
  63     const PPP_Instance_1_1* instance_interface =
  64         static_cast<const PPP_Instance_1_1*>(plugin_module_->GetPluginInterface(
  65             PPP_INSTANCE_INTERFACE_1_1));
  66     instance_interface->DidChangeView(pp_instance(), resource);
  67   }
  68 }
  69
  70 void PluginInstance::Graphics3DContextLost() {
  71   ppapi::ProxyAutoUnlock unlock;
  72   const PPP_Graphics3D_1_0* graphic_3d_interface =
  73       static_cast<const PPP_Graphics3D_1_0*>(plugin_module_->GetPluginInterface(
  74           PPP_GRAPHICS_3D_INTERFACE_1_0));
  75   // TODO(yzshen): Maybe we only need to notify for the bound graphics context?
  76   graphic_3d_interface->Graphics3DContextLost(pp_instance());
  77 }
  78
  79 bool PluginInstance::IsBoundGraphics(PP_Resource device) const {
  80   return device != 0 && device == bound_graphics_.get();
  81 }
  82
  83 PP_Bool PluginInstance::BindGraphics(PP_Instance instance, PP_Resource device) {
  84   if (bound_graphics_.get() == device)
  85     return PP_TRUE;
  86
  87   ppapi::thunk::EnterResourceNoLock<ppapi::thunk::PPB_Graphics3D_API>
  88       enter(device, false);
  89   if (enter.failed())
  90     return PP_FALSE;
  91
  92   bound_graphics_ = device;
  93   static_cast<Graphics3DResource*>(enter.object())->BindGraphics();
  94
  95   return PP_TRUE;
  96 }
  97
  98 PP_Bool PluginInstance::IsFullFrame(PP_Instance instance) {
  99   NOTIMPLEMENTED();
 100   return PP_FALSE;
 101 }
 102
 103 const ppapi::ViewData* PluginInstance::GetViewData(PP_Instance instance) {
 104   NOTIMPLEMENTED();
 105   return NULL;
 106 }
 107
 108 PP_Bool PluginInstance::FlashIsFullscreen(PP_Instance instance) {
 109   NOTIMPLEMENTED();
 110   return PP_FALSE;
 111 }
 112
 113 PP_Var PluginInstance::GetWindowObject(PP_Instance instance) {
 114   NOTIMPLEMENTED();
 115   return PP_MakeUndefined();
 116 }
 117
 118 PP_Var PluginInstance::GetOwnerElementObject(PP_Instance instance) {
 119   NOTIMPLEMENTED();
 120   return PP_MakeUndefined();
 121 }
 122
 123 PP_Var PluginInstance::ExecuteScript(PP_Instance instance,
 124                                      PP_Var script,
 125                                      PP_Var* exception) {
 126   NOTIMPLEMENTED();
 127   return PP_MakeUndefined();
 128 }
 129
 130 uint32_t PluginInstance::GetAudioHardwareOutputSampleRate(
 131     PP_Instance instance) {
 132   NOTIMPLEMENTED();
 133   return 0;
 134 }
 135
 136 uint32_t PluginInstance::GetAudioHardwareOutputBufferSize(
 137     PP_Instance instance) {
 138   NOTIMPLEMENTED();
 139   return 0;
 140 }
 141
 142 PP_Var PluginInstance::GetDefaultCharSet(PP_Instance instance) {
 143   NOTIMPLEMENTED();
 144   return PP_MakeUndefined();
 145 }
 146
 147 void PluginInstance::Log(PP_Instance instance,
 148                          PP_LogLevel log_level,
 149                          PP_Var value) {
 150   NOTIMPLEMENTED();
 151 }
 152
 153 void PluginInstance::LogWithSource(PP_Instance instance,
 154                                    PP_LogLevel log_level,
 155                                    PP_Var source,
 156                                    PP_Var value) {
 157   NOTIMPLEMENTED();
 158 }
 159
 160 void PluginInstance::SetPluginToHandleFindRequests(PP_Instance instance) {
 161   NOTIMPLEMENTED();
 162 }
 163
 164 void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
 165                                                 int32_t total,
 166                                                 PP_Bool final_result) {
 167   NOTIMPLEMENTED();
 168 }
 169
 170 void PluginInstance::SelectedFindResultChanged(PP_Instance instance,
 171                                                int32_t index) {
 172   NOTIMPLEMENTED();
 173 }
 174
 175 void PluginInstance::SetTickmarks(PP_Instance instance,
 176                                   const PP_Rect* tickmarks,
 177                                   uint32_t count) {
 178   NOTIMPLEMENTED();
 179 }
 180
 181 PP_Bool PluginInstance::IsFullscreen(PP_Instance instance) {
 182   NOTIMPLEMENTED();
 183   return PP_FALSE;
 184 }
 185
 186 PP_Bool PluginInstance::SetFullscreen(PP_Instance instance,
 187                                       PP_Bool fullscreen) {
 188   NOTIMPLEMENTED();
 189   return PP_FALSE;
 190 }
 191
 192 PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
 193   NOTIMPLEMENTED();
 194   return PP_FALSE;
 195 }
 196
 197 ppapi::Resource* PluginInstance::GetSingletonResource(
 198     PP_Instance instance,
 199     ppapi::SingletonResourceID id) {
 200   NOTIMPLEMENTED();
 201   return NULL;
 202 }
 203
 204 int32_t PluginInstance::RequestInputEvents(PP_Instance instance,
 205                                            uint32_t event_classes) {
 206   NOTIMPLEMENTED();
 207   return PP_ERROR_FAILED;
 208 }
 209
 210 int32_t PluginInstance::RequestFilteringInputEvents(PP_Instance instance,
 211                                                     uint32_t event_classes) {
 212   NOTIMPLEMENTED();
 213   return PP_ERROR_FAILED;
 214 }
 215
 216 void PluginInstance::ClearInputEventRequest(PP_Instance instance,
 217                                             uint32_t event_classes) {
 218   NOTIMPLEMENTED();
 219 }
 220
 221 void PluginInstance::StartTrackingLatency(PP_Instance instance) {
 222   NOTIMPLEMENTED();
 223 }
 224
 225 void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
 226   NOTIMPLEMENTED();
 227 }
 228
 229 int32_t PluginInstance::RegisterMessageHandler(
 230     PP_Instance instance,
 231     void* user_data,
 232     const PPP_MessageHandler_0_2* handler,
 233     PP_Resource message_loop) {
 234   NOTIMPLEMENTED();
 235   return PP_ERROR_FAILED;
 236 }
 237
 238 // TODO(dmichael): Remove this. crbug.com/414398
 239 int32_t PluginInstance::RegisterMessageHandler_1_1_Deprecated(
 240     PP_Instance instance,
 241     void* user_data,
 242     const PPP_MessageHandler_0_1_Deprecated* handler,
 243     PP_Resource message_loop) {
 244   NOTIMPLEMENTED();
 245   return PP_ERROR_FAILED;
 246 }
 247
 248 void PluginInstance::UnregisterMessageHandler(PP_Instance instance) {
 249   NOTIMPLEMENTED();
 250 }
 251
 252 PP_Bool PluginInstance::SetCursor(PP_Instance instance,
 253                                   PP_MouseCursor_Type type,
 254                                   PP_Resource image,
 255                                   const PP_Point* hot_spot) {
 256   NOTIMPLEMENTED();
 257   return PP_FALSE;
 258 }
 259
 260 int32_t PluginInstance::LockMouse(
 261     PP_Instance instance,
 262     scoped_refptr<ppapi::TrackedCallback> callback) {
 263   NOTIMPLEMENTED();
 264   return PP_ERROR_FAILED;
 265 }
 266
 267 void PluginInstance::UnlockMouse(PP_Instance instance) {
 268   NOTIMPLEMENTED();
 269 }
 270
 271 void PluginInstance::SetTextInputType(PP_Instance instance,
 272                                       PP_TextInput_Type type) {
 273   NOTIMPLEMENTED();
 274 }
 275
 276 void PluginInstance::UpdateCaretPosition(PP_Instance instance,
 277                                          const PP_Rect& caret,
 278                                          const PP_Rect& bounding_box) {
 279   NOTIMPLEMENTED();
 280 }
 281
 282 void PluginInstance::CancelCompositionText(PP_Instance instance) {
 283   NOTIMPLEMENTED();
 284 }
 285
 286 void PluginInstance::SelectionChanged(PP_Instance instance) {
 287   NOTIMPLEMENTED();
 288 }
 289
 290 void PluginInstance::UpdateSurroundingText(PP_Instance instance,
 291                                            const char* text,
 292                                            uint32_t caret,
 293                                            uint32_t anchor) {
 294   NOTIMPLEMENTED();
 295 }
 296
 297 void PluginInstance::ZoomChanged(PP_Instance instance, double factor) {
 298   NOTIMPLEMENTED();
 299 }
 300
 301 void PluginInstance::ZoomLimitsChanged(PP_Instance instance,
 302                                        double minimum_factor,
 303                                        double maximum_factor) {
 304   NOTIMPLEMENTED();
 305 }
 306
 307 PP_Var PluginInstance::GetDocumentURL(PP_Instance instance,
 308                                       PP_URLComponents_Dev* components) {
 309   NOTIMPLEMENTED();
 310   return PP_MakeUndefined();
 311 }
 312
 313 void PluginInstance::PromiseResolved(PP_Instance instance, uint32 promise_id) {
 314   NOTIMPLEMENTED();
 315 }
 316
 317 void PluginInstance::PromiseResolvedWithSession(PP_Instance instance,
 318                                                 uint32 promise_id,
 319                                                 PP_Var web_session_id_var) {
 320   NOTIMPLEMENTED();
 321 }
 322
 323 void PluginInstance::PromiseResolvedWithKeyIds(PP_Instance instance,
 324                                                uint32 promise_id,
 325                                                PP_Var key_ids_var) {
 326   NOTIMPLEMENTED();
 327 }
 328
 329 void PluginInstance::PromiseRejected(PP_Instance instance,
 330                                      uint32 promise_id,
 331                                      PP_CdmExceptionCode exception_code,
 332                                      uint32 system_code,
 333                                      PP_Var error_description_var) {
 334   NOTIMPLEMENTED();
 335 }
 336
 337 void PluginInstance::SessionMessage(PP_Instance instance,
 338                                     PP_Var web_session_id_var,
 339                                     PP_Var message_var,
 340                                     PP_Var destination_url_var) {
 341   NOTIMPLEMENTED();
 342 }
 343
 344 void PluginInstance::SessionKeysChange(PP_Instance instance,
 345                                        PP_Var web_session_id_var,
 346                                        PP_Bool has_additional_usable_key) {
 347   NOTIMPLEMENTED();
 348 }
 349
 350 void PluginInstance::SessionExpirationChange(PP_Instance instance,
 351                                              PP_Var web_session_id_var,
 352                                              PP_Time new_expiry_time) {
 353   NOTIMPLEMENTED();
 354 }
 355
 356 void PluginInstance::SessionReady(PP_Instance instance,
 357                                   PP_Var web_session_id_var) {
 358   NOTIMPLEMENTED();
 359 }
 360
 361 void PluginInstance::SessionClosed(PP_Instance instance,
 362                                    PP_Var web_session_id_var) {
 363   NOTIMPLEMENTED();
 364 }
 365
 366 void PluginInstance::SessionError(PP_Instance instance,
 367                                   PP_Var web_session_id_var,
 368                                   PP_CdmExceptionCode exception_code,
 369                                   uint32 system_code,
 370                                   PP_Var error_description_var) {
 371   NOTIMPLEMENTED();
 372 }
 373
 374 void PluginInstance::DeliverBlock(PP_Instance instance,
 375                                   PP_Resource decrypted_block,
 376                                   const PP_DecryptedBlockInfo* block_info) {
 377   NOTIMPLEMENTED();
 378 }
 379
 380 void PluginInstance::DecoderInitializeDone(PP_Instance instance,
 381                                            PP_DecryptorStreamType decoder_type,
 382                                            uint32_t request_id,
 383                                            PP_Bool success) {
 384   NOTIMPLEMENTED();
 385 }
 386
 387 void PluginInstance::DecoderDeinitializeDone(
 388     PP_Instance instance,
 389     PP_DecryptorStreamType decoder_type,
 390     uint32_t request_id) {
 391   NOTIMPLEMENTED();
 392 }
 393
 394 void PluginInstance::DecoderResetDone(PP_Instance instance,
 395                                       PP_DecryptorStreamType decoder_type,
 396                                       uint32_t request_id) {
 397   NOTIMPLEMENTED();
 398 }
 399
 400 void PluginInstance::DeliverFrame(PP_Instance instance,
 401                                   PP_Resource decrypted_frame,
 402                                   const PP_DecryptedFrameInfo* frame_info) {
 403   NOTIMPLEMENTED();
 404 }
 405
 406 void PluginInstance::DeliverSamples(PP_Instance instance,
 407                                     PP_Resource audio_frames,
 408                                     const PP_DecryptedSampleInfo* sample_info) {
 409   NOTIMPLEMENTED();
 410 }
 411
 412 PP_Var PluginInstance::ResolveRelativeToDocument(
 413     PP_Instance instance,
 414     PP_Var relative,
 415     PP_URLComponents_Dev* components) {
 416   NOTIMPLEMENTED();
 417   return PP_MakeUndefined();
 418 }
 419
 420 PP_Bool PluginInstance::DocumentCanRequest(PP_Instance instance, PP_Var url) {
 421   NOTIMPLEMENTED();
 422   return PP_FALSE;
 423 }
 424
 425 PP_Bool PluginInstance::DocumentCanAccessDocument(PP_Instance instance,
 426                                                   PP_Instance target) {
 427   NOTIMPLEMENTED();
 428   return PP_FALSE;
 429 }
 430
 431 PP_Var PluginInstance::GetPluginInstanceURL(PP_Instance instance,
 432                                             PP_URLComponents_Dev* components) {
 433   NOTIMPLEMENTED();
 434   return PP_MakeUndefined();
 435 }
 436
 437 PP_Var PluginInstance::GetPluginReferrerURL(PP_Instance instance,
 438                                             PP_URLComponents_Dev* components) {
 439   NOTIMPLEMENTED();
 440   return PP_MakeUndefined();
 441 }
 442
 443 }  // namespace examples
 444 }  // namespace mojo