Revert of Pepper takes ownership of a mailbox before passing it to the texture layer.

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 763 matching lines @@
       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::CommitTextureMailbox(
-    const cc::TextureMailbox& texture_mailbox) {
-  if (committed_texture_.IsValid() && !committed_texture_in_use_) {
-    bound_graphics_3d_->ReturnFrontBuffer(
-        committed_texture_.mailbox(), committed_texture_consumed_sync_token_,
-        false);
-  }
-
-  committed_texture_ = texture_mailbox;
-  committed_texture_in_use_ = false;
-
+void PepperPluginInstanceImpl::CommitBackingTexture() {
   if (!texture_layer_) {
     UpdateLayer(true);
     return;
   }
 
-  PassCommittedTextureToTextureLayer();
+  gpu::Mailbox mailbox;
+  gpu::SyncToken sync_token;
+  bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_token);
+  DCHECK(!mailbox.IsZero());
+  DCHECK(sync_token.HasData());
+  texture_layer_->SetTextureMailboxWithoutReleaseCallback(
+      cc::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D));
   texture_layer_->SetNeedsDisplay();
 }
 
-void PepperPluginInstanceImpl::PassCommittedTextureToTextureLayer() {
-  DCHECK(bound_graphics_3d_);
-
-  if (!committed_texture_.IsValid())
-    return;
-
-  std::unique_ptr<cc::SingleReleaseCallback> callback(
-      cc::SingleReleaseCallback::Create(base::Bind(
-          &PepperPluginInstanceImpl::FinishedConsumingCommittedTexture,
-          weak_factory_.GetWeakPtr(), committed_texture_)));
-
-  committed_texture_in_use_ = true;
-  texture_layer_->SetTextureMailbox(committed_texture_, std::move(callback));
-}
-
-void PepperPluginInstanceImpl::FinishedConsumingCommittedTexture(
-    const cc::TextureMailbox& texture_mailbox,
-    const gpu::SyncToken& sync_token,
-    bool is_lost) {
-  if (committed_texture_.mailbox() == texture_mailbox.mailbox() && !is_lost) {
-    committed_texture_in_use_ = false;
-    committed_texture_consumed_sync_token_ = sync_token;
-    return;
-  }
-
-  bound_graphics_3d_->ReturnFrontBuffer(texture_mailbox.mailbox(), sync_token,
-                                        is_lost);
-}
-
 void PepperPluginInstanceImpl::InstanceCrashed() {
   // Force free all resources and vars.
   HostGlobals::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
   SetFullscreen(false);
   FlashSetFullscreen(false, false);
   // Unbind current 2D or 3D graphics context.
   BindGraphics(pp_instance(), 0);
   InvalidateRect(gfx::Rect());
@@ skipping 1200 matching lines @@
 
   NOTREACHED();
 #endif  // ENABLE_PRINTING
   return false;
 }
 
 void PepperPluginInstanceImpl::UpdateLayer(bool force_creation) {
   if (!container_)
     return;
 
-  bool want_3d_layer = !!bound_graphics_3d_.get();
+  gpu::Mailbox mailbox;
+  gpu::SyncToken sync_token;
+  if (bound_graphics_3d_.get()) {
+    bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_token);
+  }
+  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;
   }
@@ skipping 18 matching lines @@
     }
     compositor_layer_ = NULL;
   }
 
   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();
-
-      PassCommittedTextureToTextureLayer();
+      texture_layer_->SetTextureMailboxWithoutReleaseCallback(
+          cc::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D));
     } 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
@@ skipping 1271 matching lines @@
 }
 
 void PepperPluginInstanceImpl::ConvertDIPToViewport(gfx::Rect* rect) const {
   rect->set_x(rect->x() / viewport_to_dip_scale_);
   rect->set_y(rect->y() / viewport_to_dip_scale_);
   rect->set_width(rect->width() / viewport_to_dip_scale_);
   rect->set_height(rect->height() / viewport_to_dip_scale_);
 }
 
 }  // namespace content