Converted Ppapi post swap buffer sync point to use sync tokens.

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 <utility>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
@@ skipping 735 matching lines @@
     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);
   }
 
   cc::Layer* layer =
-      texture_layer_.get() ? texture_layer_.get() : compositor_layer_.get();
+      texture_layer_ ? texture_layer_.get() : compositor_layer_.get();
   if (layer) {
     if (rect.IsEmpty()) {
       layer->SetNeedsDisplay();
     } else {
       layer->SetNeedsDisplayRect(rect);
     }
   }
 }
 
 void PepperPluginInstanceImpl::ScrollRect(int dx,
                                           int dy,
                                           const gfx::Rect& rect) {
   cc::Layer* layer =
-      texture_layer_.get() ? texture_layer_.get() : compositor_layer_.get();
+      texture_layer_ ? texture_layer_.get() : compositor_layer_.get();
   if (layer) {
     InvalidateRect(rect);
   } else if (fullscreen_container_) {
     fullscreen_container_->ScrollRect(dx, dy, rect);
   } else {
     if (full_frame_ && !IsViewAccelerated()) {
       container_->scrollRect(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.
       InvalidateRect(rect);
     }
   }
 }
 
 void PepperPluginInstanceImpl::CommitBackingTexture() {
-  if (!texture_layer_.get())
+  if (!texture_layer_) {
+    UpdateLayer(true);
     return;
+  }
+
   gpu::Mailbox mailbox;
-  uint32_t sync_point = 0;
-  bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
+  gpu::SyncToken sync_token;
+  bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_token);
   DCHECK(!mailbox.IsZero());
-  DCHECK_NE(sync_point, 0u);
+  DCHECK(sync_token.HasData());
   texture_layer_->SetTextureMailboxWithoutReleaseCallback(
-      cc::TextureMailbox(mailbox, gpu::SyncToken(sync_point), GL_TEXTURE_2D));
+      cc::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D));
   texture_layer_->SetNeedsDisplay();
 }
 
 void PepperPluginInstanceImpl::InstanceCrashed() {
   // Force free all resources and vars.
   HostGlobals::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
   SetFullscreen(false);
   FlashSetFullscreen(false, false);
@@ skipping 716 matching lines @@
 bool PepperPluginInstanceImpl::LoadTextInputInterface() {
   if (!plugin_textinput_interface_) {
     plugin_textinput_interface_ = static_cast<const PPP_TextInput_Dev*>(
         module_->GetPluginInterface(PPP_TEXTINPUT_DEV_INTERFACE));
   }
 
   return !!plugin_textinput_interface_;
 }
 
 void PepperPluginInstanceImpl::UpdateLayerTransform() {
-  if (!bound_graphics_2d_platform_ || !texture_layer_.get()) {
+  if (!bound_graphics_2d_platform_ || !texture_layer_) {
     // Currently the transform is only applied for Graphics2D.
     return;
   }
   // Set the UV coordinates of the texture based on the size of the Graphics2D
   // context. By default a texture gets scaled to the size of the layer. But
   // if the size of the Graphics2D context doesn't match the size of the plugin
   // then it will be incorrectly stretched. This also affects how the plugin
   // is painted when it is being resized. If the Graphics2D contents are
   // stretched when a plugin is resized while waiting for a new frame from the
   // plugin to be rendered, then flickering behavior occurs as in
@@ skipping 423 matching lines @@
   printing::PdfMetafileSkia* metafile =
       printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
   if (metafile)
     return metafile->InitFromData(mapper.data(), mapper.size());
 
   NOTREACHED();
 #endif  // ENABLE_PRINTING
   return false;
 }
 
-void PepperPluginInstanceImpl::UpdateLayer(bool device_changed) {
+void PepperPluginInstanceImpl::UpdateLayer(bool force_creation) {
   if (!container_)
     return;
 
   gpu::Mailbox mailbox;
-  uint32_t sync_point = 0;
+  gpu::SyncToken sync_token;
   if (bound_graphics_3d_.get()) {
-    bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
-    DCHECK_EQ(mailbox.IsZero(), sync_point == 0);
+    bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_token);
   }
-  bool want_3d_layer = !mailbox.IsZero();
+  bool want_3d_layer = !mailbox.IsZero() && sync_token.HasData();
   bool want_2d_layer = !!bound_graphics_2d_platform_;
   bool want_texture_layer = want_3d_layer || want_2d_layer;
   bool want_compositor_layer = !!bound_compositor_;
 
   if (throttler_ && throttler_->IsHiddenForPlaceholder()) {
     want_3d_layer = false;
     want_2d_layer = false;
     want_texture_layer = false;
     want_compositor_layer = false;
   }
 
-  if (!device_changed && (want_texture_layer == !!texture_layer_.get()) &&
+  if (!force_creation && (want_texture_layer == !!texture_layer_) &&
       (want_3d_layer == layer_is_hardware_) &&
       (want_compositor_layer == !!compositor_layer_.get()) &&
       layer_bound_to_fullscreen_ == !!fullscreen_container_) {
     UpdateLayerTransform();
     return;
   }
 
-  if (texture_layer_.get() || compositor_layer_.get()) {
+  if (texture_layer_ || compositor_layer_) {
     if (!layer_bound_to_fullscreen_)
       container_->setWebLayer(NULL);
     else if (fullscreen_container_)
       fullscreen_container_->SetLayer(NULL);
     web_layer_.reset();
     if (texture_layer_) {
       texture_layer_->ClearClient();
       texture_layer_ = NULL;
     }
     compositor_layer_ = NULL;
   }
 
   if (want_texture_layer) {
     bool opaque = false;
     if (want_3d_layer) {
       DCHECK(bound_graphics_3d_.get());
       texture_layer_ = cc::TextureLayer::CreateForMailbox(
           cc_blink::WebLayerImpl::LayerSettings(), NULL);
       opaque = bound_graphics_3d_->IsOpaque();
       texture_layer_->SetTextureMailboxWithoutReleaseCallback(
-          cc::TextureMailbox(mailbox, gpu::SyncToken(sync_point),
-                             GL_TEXTURE_2D));
+          cc::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D));
     } else {
       DCHECK(bound_graphics_2d_platform_);
       texture_layer_ = cc::TextureLayer::CreateForMailbox(
           cc_blink::WebLayerImpl::LayerSettings(), 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
@@ skipping 1251 matching lines @@
 
 void PepperPluginInstanceImpl::RecordFlashJavaScriptUse() {
   if (initialized_ && !javascript_used_ && is_flash_plugin_) {
     javascript_used_ = true;
     RenderThread::Get()->RecordAction(
         base::UserMetricsAction("Flash.JavaScriptUsed"));
   }
 }
 
 }  // namespace content