Migrate Graphics2D to new design.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 59 matching lines @@
 #include "webkit/plugins/ppapi/content_decryptor_delegate.h"
 #include "webkit/plugins/ppapi/event_conversion.h"
 #include "webkit/plugins/ppapi/fullscreen_container.h"
 #include "webkit/plugins/ppapi/gfx_conversion.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/message_channel.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
-#include "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
 #include "webkit/plugins/ppapi/ppp_pdf.h"
 #include "webkit/plugins/ppapi/url_request_info_util.h"
 #include "webkit/plugins/sad_plugin.h"
 
 #if defined(OS_MACOSX)
 #include "printing/metafile_impl.h"
 #if !defined(USE_SKIA)
@@ skipping 15 matching lines @@
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/gdi_util.h"
 #endif
 
 using base::StringPrintf;
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
 using ppapi::PPB_InputEvent_Shared;
 using ppapi::PPB_View_Shared;
 using ppapi::PPP_Instance_Combined;
+using ppapi::Resource;
 using ppapi::ScopedPPResource;
 using ppapi::StringVar;
 using ppapi::TrackedCallback;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::Var;
 using ppapi::ArrayBufferVar;
@@ skipping 207 matching lines @@
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
       sent_initial_did_change_view_(false),
       view_change_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      bound_graphics_2d_platform_(NULL),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_messaging_interface_(NULL),
       plugin_mouse_lock_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_private_interface_(NULL),
       plugin_selection_interface_(NULL),
@@ skipping 97 matching lines @@
   TRACE_EVENT0("ppapi", "PluginInstance::Paint");
   if (module()->is_crashed()) {
     // Crashed plugin painting.
     if (!sad_plugin_)  // Lazily initialize bitmap.
       sad_plugin_ = delegate_->GetSadPluginBitmap();
     if (sad_plugin_)
       webkit::PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
     return;
   }
 
-  PPB_Graphics2D_Impl* bound_graphics_2d = GetBoundGraphics2D();
+  PluginDelegate::PlatformGraphics2D* bound_graphics_2d = GetBoundGraphics2D();
   if (bound_graphics_2d)
     bound_graphics_2d->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
@@ skipping 442 matching lines @@
 }
 
 bool PluginInstance::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip,
     float* scale_factor) {
   if (!always_on_top_)
     return false;
-  if (!GetBoundGraphics2D() || !GetBoundGraphics2D()->is_always_opaque())
+  if (!GetBoundGraphics2D() || !GetBoundGraphics2D()->IsAlwaysOpaque())
     return false;
 
   // We specifically want to compare against the area covered by the backing
   // store when seeing if we cover the given paint bounds, since the backing
   // store could be smaller than the declared plugin area.
-  PPB_ImageData_Impl* image_data = GetBoundGraphics2D()->image_data();
+  PPB_ImageData_Impl* image_data = GetBoundGraphics2D()->ImageData();
   // ImageDatas created by NaCl don't have a PlatformImage, so can't be
   // optimized this way.
   if (!image_data->PlatformImage())
     return false;
 
   gfx::Point plugin_origin = PP_ToGfxPoint(view_data_.rect.point);
   gfx::Vector2d plugin_offset = plugin_origin.OffsetFromOrigin();
   // Convert |paint_bounds| to be relative to the left-top corner of the plugin.
   gfx::Rect relative_paint_bounds(paint_bounds);
   relative_paint_bounds.Offset(-plugin_offset);
@@ skipping 734 matching lines @@
     skia::EndPlatformPaint(canvas);
   }
 #endif  // defined(OS_WIN)
 
   return ret;
 #else  // defined(ENABLE_PRINTING)
   return false;
 #endif
 }
 
-PPB_Graphics2D_Impl* PluginInstance::GetBoundGraphics2D() const {
-  if (bound_graphics_.get() == NULL)
-    return NULL;
-
-  if (bound_graphics_->AsPPB_Graphics2D_API())
-    return static_cast<PPB_Graphics2D_Impl*>(bound_graphics_.get());
-  return NULL;
+PluginDelegate::PlatformGraphics2D* PluginInstance::GetBoundGraphics2D() const {
+  return bound_graphics_2d_platform_;
 }
 
 PPB_Graphics3D_Impl* PluginInstance::GetBoundGraphics3D() const {
-  if (bound_graphics_.get() == NULL)
+  if (bound_graphics_3d_.get() == NULL)
     return NULL;
-
-  if (bound_graphics_->AsPPB_Graphics3D_API())
-    return static_cast<PPB_Graphics3D_Impl*>(bound_graphics_.get());
-  return NULL;
+  return static_cast<PPB_Graphics3D_Impl*>(bound_graphics_3d_.get());
 }
 
 void PluginInstance::setBackingTextureId(unsigned int id, bool is_opaque) {
   // If we have a fullscreen_container_ (under PPB_FlashFullscreen)
   // or desired_fullscreen_state is true (under PPB_Fullscreen),
   // then the plugin is fullscreen or transitioning to fullscreen
   // and the parent context is not the one for the browser page,
   // but for the fullscreen window, and so the parent texture ID
   // doesn't correspond to anything in the page's context.
   //
@@ skipping 140 matching lines @@
   // Do nothing so that the pending user gesture will stay open for
   // kUserGestureDurationInSeconds.
   // TODO(yzshen): remove the code for closing pending user gesture.
 }
 
 PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
                                      PP_Resource device) {
   TRACE_EVENT0("ppapi", "PluginInstance::BindGraphics");
   // The Graphics3D instance can't be destroyed until we call
   // setBackingTextureId.
-  scoped_refptr< ::ppapi::Resource> old_graphics = bound_graphics_;
-  if (bound_graphics_.get()) {
-    if (GetBoundGraphics2D()) {
-      GetBoundGraphics2D()->BindToInstance(NULL);
-    } else if (GetBoundGraphics3D()) {
+  scoped_refptr< ::ppapi::Resource> old_graphics = bound_graphics_3d_;
+  if (bound_graphics_3d_.get()) {
+    if (GetBoundGraphics3D()) {
       GetBoundGraphics3D()->BindToInstance(false);
     }
-    bound_graphics_ = NULL;
+    bound_graphics_3d_ = NULL;
+  }
+  if (bound_graphics_2d_platform_) {
+    GetBoundGraphics2D()->BindToInstance(NULL);
+    bound_graphics_2d_platform_ = NULL;
   }
 
   // Special-case clearing the current device.
   if (!device) {
     setBackingTextureId(0, false);
     InvalidateRect(gfx::Rect());
     return PP_TRUE;
   }
 
   // Refuse to bind if in transition to fullscreen with PPB_FlashFullscreen or
   // to/from fullscreen with PPB_Fullscreen.
   if ((fullscreen_container_ && !flash_fullscreen_) ||
       desired_fullscreen_state_ != view_data_.is_fullscreen)
     return PP_FALSE;
 
-  EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
-  PPB_Graphics2D_Impl* graphics_2d = enter_2d.succeeded() ?
-      static_cast<PPB_Graphics2D_Impl*>(enter_2d.object()) : NULL;
+  bound_graphics_2d_platform_ = delegate_->GetGraphics2D(this, device);
   EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
   PPB_Graphics3D_Impl* graphics_3d = enter_3d.succeeded() ?
       static_cast<PPB_Graphics3D_Impl*>(enter_3d.object()) : NULL;
 
-  if (graphics_2d) {
-    if (graphics_2d->pp_instance() != pp_instance())
-      return PP_FALSE;  // Can't bind other instance's contexts.
-    if (!graphics_2d->BindToInstance(this))
+  if (bound_graphics_2d_platform_) {
+    if (!bound_graphics_2d_platform_->BindToInstance(this))
       return PP_FALSE;  // Can't bind to more than one instance.
 
-    bound_graphics_ = graphics_2d;
-    setBackingTextureId(0, graphics_2d->is_always_opaque());
+    setBackingTextureId(0, bound_graphics_2d_platform_->IsAlwaysOpaque());
     // BindToInstance will have invalidated the plugin if necessary.
   } else if (graphics_3d) {
     // Make sure graphics can only be bound to the instance it is
     // associated with.
     if (graphics_3d->pp_instance() != pp_instance())
       return PP_FALSE;
     if (!graphics_3d->BindToInstance(true))
       return PP_FALSE;
 
-    bound_graphics_ = graphics_3d;
+    bound_graphics_3d_ = graphics_3d;
     setBackingTextureId(graphics_3d->GetBackingTextureId(),
                         graphics_3d->IsOpaque());
   } else {
     // The device is not a valid resource type.
     return PP_FALSE;
   }
 
   return PP_TRUE;
 }
 
@@ skipping 552 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit