[Reland 1] Pepper takes ownership of a mailbox before passing it to the texture layer.

content/renderer/pepper/pepper_plugin_instance_impl.h

 // 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.
 
 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 #define CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "build/build_config.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/texture_layer_client.h"
+#include "cc/resources/texture_mailbox.h"
 #include "content/common/content_export.h"
 #include "content/public/renderer/pepper_plugin_instance.h"
 #include "content/public/renderer/plugin_instance_throttler.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/renderer/mouse_lock_dispatcher.h"
 #include "gin/handle.h"
 #include "ppapi/c/dev/pp_cursor_type_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/dev/ppp_text_input_dev.h"
@@ skipping 153 matching lines @@
   // relative to the top-left of the plugin. This does nothing if the plugin
   // has not yet been positioned. You can supply an empty gfx::Rect() to
   // invalidate the entire plugin.
   void InvalidateRect(const gfx::Rect& rect);
 
   // Schedules a scroll of the plugin.  This uses optimized scrolling only for
   // full-frame plugins, as otherwise there could be other elements on top.  The
   // slow path can also be triggered if there is an overlapping frame.
   void ScrollRect(int dx, int dy, const gfx::Rect& rect);
 
-  // Commit the backing texture to the screen once the side effects some
-  // rendering up to an offscreen SwapBuffers are visible.
-  void CommitBackingTexture();
+  // Commit the texture mailbox to the screen.
+  void CommitTextureMailbox(const cc::TextureMailbox& texture_mailbox);
+
+  // Passes the committed texture to |texture_layer_| and marks it as in use.
+  void PassCommittedTextureToTextureLayer();
+
+  // Callback when the compositor is finished consuming the committed texture.
+  void FinishedConsumingCommittedTexture(
+      const cc::TextureMailbox& texture_mailbox,
+      const gpu::SyncToken& sync_token,
+      bool is_lost);
 
   // Called when the out-of-process plugin implementing this instance crashed.
   void InstanceCrashed();
 
   // PPB_Instance and PPB_Instance_Private implementation.
   bool full_frame() const { return full_frame_; }
   const ppapi::ViewData& view_data() const { return view_data_; }
 
   // PPP_Instance and PPP_Instance_Private.
   bool Initialize(const std::vector<std::string>& arg_names,
@@ skipping 482 matching lines @@
   void DidDataFromWebURLResponse(const blink::WebURLResponse& response,
                                  int pending_host_id,
                                  const ppapi::URLResponseInfoData& data);
 
   void RecordFlashJavaScriptUse();
 
   // Converts the PP_Rect between DIP and Viewport.
   void ConvertRectToDIP(PP_Rect* rect) const;
   void ConvertDIPToViewport(gfx::Rect* rect) const;
 
+  // Each time CommitTextureMailbox() is called, this instance is given
+  // ownership
+  // of a cc::TextureMailbox. This instance always needs to hold on to the most
+  // recently committed cc::TextureMailbox, since UpdateLayer() might require
+  // it.
+  // Since it is possible for a cc::TextureMailbox to be passed to
+  // texture_layer_ more than once, a reference counting mechanism is necessary
+  // to ensure that a cc::TextureMailbox isn't returned until all copies of it
+  // have been released by texture_layer_.
+  //
+  // This method should be called each time a cc::TextureMailbox is passed to
+  // |texture_layer_|. It increments an internal reference count.
+  void IncrementTextureReferenceCount(const cc::TextureMailbox& mailbox);
+
+  // This method should be called each time |texture_layer_| finishes consuming
+  // a cc::TextureMailbox. It decrements an internal reference count. Returns
+  // whether the last reference was removed.
+  bool DecrementTextureReferenceCount(const cc::TextureMailbox& mailbox);
+
+  // Whether a given cc::TextureMailbox is in use by |texture_layer_|.
+  bool IsTextureInUse(const cc::TextureMailbox& mailbox) const;
+
   RenderFrameImpl* render_frame_;
   base::Closure instance_deleted_callback_;
   scoped_refptr<PluginModule> module_;
   std::unique_ptr<ppapi::PPP_Instance_Combined> instance_interface_;
   // If this is the NaCl plugin, we create a new module when we switch to the
   // IPC-based PPAPI proxy. Store the original module and instance interface
   // so we can shut down properly.
   scoped_refptr<PluginModule> original_module_;
   std::unique_ptr<ppapi::PPP_Instance_Combined> original_instance_interface_;
 
@@ skipping 211 matching lines @@
   // Isolate in which this Instance was created when interacting with v8.
   v8::Isolate* isolate_;
 
   std::unique_ptr<MouseLockDispatcher::LockTarget> lock_target_;
 
   bool is_deleted_;
 
   // The text that is currently selected in the plugin.
   base::string16 selected_text_;
 
+  // The most recently committed texture. This is kept around in case the layer
+  // needs to be regenerated.
+  cc::TextureMailbox committed_texture_;
+
+  gpu::SyncToken committed_texture_consumed_sync_token_;
+
+  // Holds the number of references |texture_layer_| has to any given
+  // cc::TextureMailbox.
+  // We expect there to be no more than 10 textures in use at a time. A
+  // std::vector will have better performance than a std::map.
+  using TextureMailboxRefCount = std::pair<cc::TextureMailbox, int>;
+  std::vector<TextureMailboxRefCount> texture_ref_counts_;
+
   bool initialized_;
 
   // We use a weak ptr factory for scheduling DidChangeView events so that we
   // can tell whether updates are pending and consolidate them. When there's
   // already a weak ptr pending (HasWeakPtrs is true), code should update the
   // view_data_ but not send updates. This also allows us to cancel scheduled
   // view change events.
   base::WeakPtrFactory<PepperPluginInstanceImpl> view_change_weak_ptr_factory_;
   base::WeakPtrFactory<PepperPluginInstanceImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperPluginInstanceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_