Implement TextureImageTransportSurface using texture mailbox

content/browser/renderer_host/render_widget_host_view_aura.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_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/image_transport_factory.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_export.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/gfx/rect.h"
 #include "webkit/glue/webcursor.h"
@@ skipping 88 matching lines @@
       const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
       int gpu_host_id) OVERRIDE;
   virtual void AcceleratedSurfacePostSubBuffer(
       const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
       int gpu_host_id) OVERRIDE;
   virtual void AcceleratedSurfaceSuspend() OVERRIDE;
   virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE;
   virtual void AcceleratedSurfaceNew(
       int32 width_in_pixel,
       int32 height_in_pixel,
-      uint64 surface_id) OVERRIDE;
+      uint64 surface_id,
+      const std::vector<signed char>& mailbox_name) OVERRIDE;
   virtual void AcceleratedSurfaceRelease(uint64 surface_id) OVERRIDE;
   virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE;
   virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE;
   virtual void ProcessAckedTouchEvent(const WebKit::WebTouchEvent& touch,
                                       bool processed) OVERRIDE;
   virtual void SetHasHorizontalScrollbar(
       bool has_horizontal_scrollbar) OVERRIDE;
   virtual void SetScrollOffsetPinning(
       bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE;
   virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE;
@@ skipping 99 matching lines @@
 
   // If |clip| is non-empty and and doesn't contain |rect| or |clip| is empty
   // SchedulePaint() is invoked for |rect|.
   void SchedulePaintIfNotInClip(const gfx::Rect& rect, const gfx::Rect& clip);
 
   // Helper method to determine if, in mouse locked mode, the cursor should be
   // moved to center.
   bool ShouldMoveToCenter();
 
   // Run the compositing callbacks.
-  void RunCompositingDidCommitCallbacks(ui::Compositor* compositor);
-  void RunCompositingWillStartCallbacks(ui::Compositor* compositor);
+  void RunCompositingDidCommitCallbacks();
+  void RunCompositingWillStartCallbacks();
 
   // Insert a sync point into the compositor's command stream and acknowledge
   // that we have presented the accelerated surface buffer.
   static void InsertSyncPointAndACK(int32 route_id,
                                     int gpu_host_id,
-                                    ui::Compositor* compositor);
+                                    scoped_refptr<ui::Texture> texture);
 
   // Called when window_ is removed from the window tree.
   void RemovingFromRootWindow();
 
-  // After clearing |current_surface_|, and waiting for the compositor to finish
-  // using it, call this to inform the gpu process.
-  void SetSurfaceNotInUseByCompositor(ui::Compositor* compositor);
+  // Called after commit for the last reference to the texture going away
+  // after it was released as the frontbuffer.
+  void SetSurfaceNotInUseByCompositor(scoped_refptr<ui::Texture>);
 
-  // This is called every time |current_surface_| usage changes (by thumbnailer,
-  // compositor draws, and tab visibility). Every time usage of current surface
-  // changes between "may be used" and "certain to not be used" by the ui, we
-  // inform the gpu process.
-  void AdjustSurfaceProtection();
-
-  // Called after async thumbnailer task completes.  Used to call
-  // AdjustSurfaceProtection.
+  // Called after async thumbnailer task completes.
+  // Holds a reference to the texture through the bound argument.
   void CopyFromCompositingSurfaceFinished(base::Callback<void(bool)> callback,
+                                          scoped_refptr<ui::Texture>,
                                           bool result);
 
   ui::Compositor* GetCompositor();
 
   // Detaches |this| from the input method object.
   void DetachFromInputMethod();
 
   // Converts |rect| from window coordinate to screen coordinate.
   gfx::Rect ConvertRectToScreen(const gfx::Rect& rect);
 
+  void SwapBuffersBegin(const gfx::Size& surface_size);
+  void SwapBuffersCompleted(int gpu_host_id,
+                            int route_id,
+                            scoped_refptr<ui::Texture> pending_surface);
   // The model object.
   RenderWidgetHostImpl* host_;
 
   aura::Window* window_;
 
   scoped_ptr<WindowObserver> window_observer_;
 
   // Are we in the process of closing?  Tracked so fullscreen views can avoid
   // sending a second shutdown request to the host when they lose the focus
   // after requesting shutdown for another reason (e.g. Escape key).
@@ skipping 32 matching lines @@
 
   // Indicates if there is onging composition text.
   bool has_composition_text_;
 
   // Current tooltip text.
   string16 tooltip_;
 
   // The scale factor of the display the renderer is currently on.
   float device_scale_factor_;
 
-  std::vector< base::Callback<void(ui::Compositor*)> >
-      on_compositing_did_commit_callbacks_;
+  std::vector<base::Closure> on_compositing_did_commit_callbacks_;
 
-  std::vector< base::Callback<void(ui::Compositor*)> >
-      on_compositing_will_start_callbacks_;
+  std::vector<base::Closure> on_compositing_will_start_callbacks_;
 
-  std::map<uint64, scoped_refptr<ui::Texture> >
-      image_transport_clients_;
+  // The current frontbuffer
+  scoped_refptr<ui::Texture> current_surface_;
 
-  uint64 current_surface_;
+  // The buffer pending to become our new frontbuffer during a swap

[no sievers, 2012/11/02 01:29:14]

Actually this is the previous one, the one to be released back to the producer
when we ack the swap.

+  scoped_refptr<ui::Texture> pending_surface_;
 
-  // Protected means that the |current_surface_| may be in use by ui and cannot
-  // be safely discarded. Things to consider are thumbnailer, compositor draw,
-  // and tab visibility.
-  bool current_surface_is_protected_;
-  bool current_surface_in_use_by_compositor_;
+  std::vector<signed char> mailbox_name_;
 
   std::vector<base::Callback<void(bool)> > pending_thumbnail_tasks_;
 
-  // This id increments every time surface_is_protected changes. We tag IPC
-  // messages which rely on protection state with this id to stay in sync.
-  uint32 protection_state_id_;
-
-  int32 surface_route_id_;
-
   gfx::GLSurfaceHandle shared_surface_handle_;
 
   // If non-NULL we're in OnPaint() and this is the supplied canvas.
   gfx::Canvas* paint_canvas_;
 
   // Used to record the last position of the mouse.
   // While the mouse is locked, they store the last known position just as mouse
   // lock was entered.
   // Relative to the upper-left corner of the view.
   gfx::Point unlocked_mouse_position_;
@@ skipping 26 matching lines @@
   // Used to track the state of the window we're created from. Only used when
   // created fullscreen.
   scoped_ptr<aura::WindowTracker> host_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_