[PPAPI] Compositor API implementation

content/renderer/pepper/pepper_plugin_instance_impl.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 "content/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 13 matching lines @@
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/event_conversion.h"
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/message_channel.h"
 #include "content/renderer/pepper/npapi_glue.h"
 #include "content/renderer/pepper/pepper_browser_connection.h"
+#include "content/renderer/pepper/pepper_compositor_host.h"
 #include "content/renderer/pepper/pepper_file_ref_renderer_host.h"
 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
 #include "content/renderer/pepper/pepper_in_process_router.h"
 #include "content/renderer/pepper/pepper_url_loader_host.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/plugin_object.h"
 #include "content/renderer/pepper/ppb_buffer_impl.h"
 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
@@ skipping 448 matching lines @@
     : RenderFrameObserver(render_frame),
       render_frame_(render_frame),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(container),
       layer_bound_to_fullscreen_(false),
       plugin_url_(plugin_url),
       full_frame_(false),
       sent_initial_did_change_view_(false),
+      bound_graphics_3d_(NULL),
       bound_graphics_2d_platform_(NULL),
+      bound_compositor_(NULL),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_mouse_lock_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_private_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_textinput_interface_(NULL),
@@ skipping 185 matching lines @@
       fullscreen_container_->InvalidateRect(rect);
   } else {
     if (!container_ || view_data_.rect.size.width == 0 ||
         view_data_.rect.size.height == 0)
       return;  // Nothing to do.
     if (rect.IsEmpty())
       container_->invalidate();
     else
       container_->invalidateRect(rect);
   }
-  if (texture_layer_) {
+  scoped_refptr<cc::Layer> layer = texture_layer_ ?
+      static_cast<scoped_refptr<cc::Layer> >(texture_layer_) :
+      static_cast<scoped_refptr<cc::Layer> >(compositor_layer_);
+  if (layer) {
     if (rect.IsEmpty()) {
-      texture_layer_->SetNeedsDisplay();
+      layer->SetNeedsDisplay();
     } else {
-      texture_layer_->SetNeedsDisplayRect(rect);
+      layer->SetNeedsDisplayRect(rect);
     }
   }
 }
 
 void PepperPluginInstanceImpl::ScrollRect(int dx,
                                           int dy,
                                           const gfx::Rect& rect) {
-  if (texture_layer_) {
+  scoped_refptr<cc::Layer> layer = texture_layer_ ?
+      static_cast<scoped_refptr<cc::Layer> >(texture_layer_) :
+      static_cast<scoped_refptr<cc::Layer> >(compositor_layer_);
+  if (layer) {
     InvalidateRect(rect);
   } else if (fullscreen_container_) {
     fullscreen_container_->ScrollRect(dx, dy, rect);
   } else {
     if (full_frame_ && !IsViewAccelerated()) {
       container_->scrollRect(dx, dy, rect);
     } else {
       // Can't do optimized scrolling since there could be other elements on top
       // of us or the view renders via the accelerated compositor which is
       // incompatible with the move and backfill scrolling model.
@@ skipping 422 matching lines @@
     new_clip = clip;
 
   cut_outs_rects_ = cut_outs_rects;
 
   view_data_.rect = PP_FromGfxRect(position);
   view_data_.clip_rect = PP_FromGfxRect(clip);
   view_data_.device_scale = container_->deviceScaleFactor();
   view_data_.css_scale =
       container_->pageZoomFactor() * container_->pageScaleFactor();
 
+  if (texture_layer_)
+    texture_layer_->SetBounds(position.size());

[raymes, 2014/06/02 03:51:08]

Why is this added?

[Peng, 2014/06/02 19:01:55]

Oops! 

Done.

+
   if (desired_fullscreen_state_ || view_data_.is_fullscreen) {
     WebElement element = container_->element();
     WebDocument document = element.document();
     bool is_fullscreen_element = (element == document.fullScreenElement());
     if (!view_data_.is_fullscreen && desired_fullscreen_state_ &&
         render_frame()->GetRenderWidget()->is_fullscreen() &&
         is_fullscreen_element) {
       // Entered fullscreen. Only possible via SetFullscreen().
       view_data_.is_fullscreen = true;
     } else if (view_data_.is_fullscreen && !is_fullscreen_element) {
@@ skipping 53 matching lines @@
   // |view_data_| haven't been properly initialized.
   if (sent_initial_did_change_view_)
     SendDidChangeView();
 }
 
 void PepperPluginInstanceImpl::ViewInitiatedPaint() {
   if (bound_graphics_2d_platform_)
     bound_graphics_2d_platform_->ViewInitiatedPaint();
   else if (bound_graphics_3d_.get())
     bound_graphics_3d_->ViewInitiatedPaint();
+  else if (bound_compositor_)
+    bound_compositor_->ViewInitiatedPaint();
 }
 
 void PepperPluginInstanceImpl::ViewFlushedPaint() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (bound_graphics_2d_platform_)
     bound_graphics_2d_platform_->ViewFlushedPaint();
   else if (bound_graphics_3d_.get())
     bound_graphics_3d_->ViewFlushedPaint();
+  else if (bound_compositor_)
+    bound_compositor_->ViewFlushedPaint();
 }
 
 void PepperPluginInstanceImpl::SetSelectedText(
     const base::string16& selected_text) {
   selected_text_ = selected_text;
 }
 
 void PepperPluginInstanceImpl::SetLinkUnderCursor(const std::string& url) {
   link_under_cursor_ = base::UTF8ToUTF16(url);
 }
@@ skipping 664 matching lines @@
     return;
 
   gpu::Mailbox mailbox;
   uint32 sync_point = 0;
   if (bound_graphics_3d_.get()) {
     bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
     DCHECK_EQ(mailbox.IsZero(), sync_point == 0);
   }
   bool want_3d_layer = !mailbox.IsZero();
   bool want_2d_layer = !!bound_graphics_2d_platform_;
-  bool want_layer = want_3d_layer || want_2d_layer;
+  bool want_texture_layer = want_3d_layer || want_2d_layer;
+  bool want_compositor_layer = !!bound_compositor_;
 
-  if ((want_layer == !!texture_layer_.get()) &&
+  if ((want_texture_layer == !!texture_layer_.get()) &&
       (want_3d_layer == layer_is_hardware_) &&
       layer_bound_to_fullscreen_ == !!fullscreen_container_) {
     UpdateLayerTransform();
     return;
   }
 
-  if (texture_layer_) {
+  if (texture_layer_ || compositor_layer_) {
     if (!layer_bound_to_fullscreen_)
       container_->setWebLayer(NULL);
     else if (fullscreen_container_)
       fullscreen_container_->SetLayer(NULL);
     web_layer_.reset();
     texture_layer_ = NULL;
+    compositor_layer_ = NULL;
   }
-  if (want_layer) {
+
+  if (want_texture_layer) {
     bool opaque = false;
     if (want_3d_layer) {
       DCHECK(bound_graphics_3d_.get());
       texture_layer_ = cc::TextureLayer::CreateForMailbox(NULL);
       opaque = bound_graphics_3d_->IsOpaque();
       texture_layer_->SetTextureMailboxWithoutReleaseCallback(
           cc::TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point));
     } else {
       DCHECK(bound_graphics_2d_platform_);
       texture_layer_ = cc::TextureLayer::CreateForMailbox(this);
       bound_graphics_2d_platform_->AttachedToNewLayer();
       opaque = bound_graphics_2d_platform_->IsAlwaysOpaque();
       texture_layer_->SetFlipped(false);
     }
+
+    // Ignore transparency in fullscreen, since that's what Flash always
+    // wants to do, and that lets it not recreate a context if
+    // wmode=transparent was specified.
+    opaque = opaque || fullscreen_container_;
+    texture_layer_->SetContentsOpaque(opaque);
     web_layer_.reset(new webkit::WebLayerImpl(texture_layer_));
+  } else if (want_compositor_layer) {
+    compositor_layer_ = bound_compositor_->layer();
+    web_layer_.reset(new webkit::WebLayerImpl(compositor_layer_));
+  }
+
+  if (web_layer_) {
     if (fullscreen_container_) {
       fullscreen_container_->SetLayer(web_layer_.get());
-      // Ignore transparency in fullscreen, since that's what Flash always
-      // wants to do, and that lets it not recreate a context if
-      // wmode=transparent was specified.
-      texture_layer_->SetContentsOpaque(true);
     } else {
       container_->setWebLayer(web_layer_.get());
-      texture_layer_->SetContentsOpaque(opaque);
     }
   }
+
   layer_bound_to_fullscreen_ = !!fullscreen_container_;
   layer_is_hardware_ = want_3d_layer;
   UpdateLayerTransform();
 }
 
 bool PepperPluginInstanceImpl::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!bound_graphics_2d_platform_)
@@ skipping 146 matching lines @@
   // UpdateLayer().
   scoped_refptr<ppapi::Resource> old_graphics = bound_graphics_3d_.get();
   if (bound_graphics_3d_.get()) {
     bound_graphics_3d_->BindToInstance(false);
     bound_graphics_3d_ = NULL;
   }
   if (bound_graphics_2d_platform_) {
     bound_graphics_2d_platform_->BindToInstance(NULL);
     bound_graphics_2d_platform_ = NULL;
   }
+  if (bound_compositor_) {
+    bound_compositor_->BindToInstance(NULL);
+    bound_compositor_ = NULL;
+  }
 
   // Special-case clearing the current device.
   if (!device) {
     UpdateLayer();
     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;
 
   const ppapi::host::PpapiHost* ppapi_host =
       RendererPpapiHost::GetForPPInstance(instance)->GetPpapiHost();
   ppapi::host::ResourceHost* host = ppapi_host->GetResourceHost(device);
   PepperGraphics2DHost* graphics_2d = NULL;
+  PepperCompositorHost* compositor = NULL;
   if (host) {
-    if (host->IsGraphics2DHost())
+    if (host->IsGraphics2DHost()) {
       graphics_2d = static_cast<PepperGraphics2DHost*>(host);
-    DLOG_IF(ERROR, !graphics_2d) << "Resource is not PepperGraphics2DHost.";
+    } else if (host->IsCompositorHost()) {
+      compositor = static_cast <PepperCompositorHost*>(host);
+    } else {
+      DLOG(ERROR) <<
+          "Resource is not PepperCompositorHost or PepperGraphics2DHost.";
+    }
   }
 
   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 (compositor) {
+    if (compositor->BindToInstance(this)) {
+      bound_compositor_ = compositor;
+      UpdateLayer();
+      return PP_TRUE;
+    }
+  } else if (graphics_2d) {
     if (graphics_2d->BindToInstance(this)) {
       bound_graphics_2d_platform_ = graphics_2d;
       UpdateLayer();
       return PP_TRUE;
     }
   } 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() &&
         graphics_3d->BindToInstance(true)) {
@@ skipping 958 matching lines @@
     // Running out-of-process. Initiate an IPC call to notify the plugin
     // process.
     ppapi::proxy::HostDispatcher* dispatcher =
         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
     dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
         ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
   }
 }
 
 }  // namespace content