Drop frontbuffers with ui-use-gpu-process, synchronized with browser, decoupled from backbuffer dro…

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_
 #pragma once
 
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.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"
 
+namespace aura {
+class CompositorLock;
+}
+
 namespace content {
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 }
 
 namespace gfx {
 class Canvas;
 }
 
 namespace ui {
 class InputMethod;
 }
 
 namespace WebKit {
 class WebTouchEvent;
 }
 
 class ImageTransportClient;
 
 // RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
 class RenderWidgetHostViewAura
     : public content::RenderWidgetHostViewBase,
       public ui::CompositorObserver,
       public ui::TextInputClient,
       public aura::WindowDelegate,
       public aura::client::ActivationDelegate,
-      public ImageTransportFactoryObserver {
+      public ImageTransportFactoryObserver,
+      public base::SupportsWeakPtr<RenderWidgetHostViewAura> {
  public:
   virtual ~RenderWidgetHostViewAura();
 
   // RenderWidgetHostView implementation.
   virtual void InitAsChild(gfx::NativeView parent_view) OVERRIDE;
   virtual content::RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual void SetBounds(const gfx::Rect& rect) OVERRIDE;
   virtual gfx::NativeView GetNativeView() const OVERRIDE;
   virtual gfx::NativeViewId GetNativeViewId() const OVERRIDE;
@@ skipping 42 matching lines @@
       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,
-      TransportDIB::Handle* surface_handle) OVERRIDE;
+      TransportDIB::Handle* surface_handle,
+      int32 route_id) OVERRIDE;
   virtual void AcceleratedSurfaceRelease(uint64 surface_id) OVERRIDE;
   virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE;
   virtual gfx::Rect GetRootWindowBounds() OVERRIDE;
   virtual void ProcessTouchAck(WebKit::WebInputEvent::Type type,
                                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 89 matching lines @@
   // Helper method to determine if, in mouse locked mode, the cursor should be
   // moved to center.
   bool ShouldMoveToCenter();
 
   // Run the compositing callbacks.
   void RunCompositingCallbacks();
 
   // Called when window_ is removed from the window tree.
   void RemovingFromRootWindow();
 
+  void SetSurfaceNotInUseByCompositor(uint32 expected_visibility_state_id);
+  void AdjustSurfaceProtection();
+
+  void CopyFromCompositingSurfaceFinished(base::Callback<void(bool)> callback,
+                                          bool result);
+
   ui::Compositor* GetCompositor();
 
   // The model object.
   content::RenderWidgetHostImpl* host_;
 
   aura::Window* window_;
 
   scoped_ptr<WindowObserver> window_observer_;
 
   // Are we in the process of closing?  Tracked so fullscreen views can avoid
@@ skipping 35 matching lines @@
   // Current tooltip text.
   string16 tooltip_;
 
   std::vector< base::Callback<void(void)> > on_compositing_ended_callbacks_;
 
   std::map<uint64, scoped_refptr<ImageTransportClient> >
       image_transport_clients_;
 
   uint64 current_surface_;
 
+  // protected means that the current_surface_ may be in use by ui and cannot

[piman, 2012/06/12 20:59:48]

nit: Protected (cap 1st letter)

+  // be safely discarded. Things to consider are thumbnailerm compositor draw

[piman, 2012/06/12 20:59:48]

typo: thumbnailer,

+  // pending, and tab visibility.
+  bool current_surface_is_protected_;
+  bool current_surface_in_use_by_compositor_;
+
+  int pending_thumbnail_tasks_;
+
+  // This id increments every time visibility changes. Keeps gpu/browser IPC
+  // IPC messages relying on visibility state tagged and in sync.
+  uint32 visibility_state_id_;
+
+  int32 route_id_;

[piman, 2012/06/12 20:59:48]

nit: maybe rename this as "surface_route_id_" to make it clear this is the
routing id for the surface, not the view.

+
   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 12 matching lines @@
   bool needs_update_texture_;
 
   // Used to prevent further resizes while a resize is pending.
   class ResizeLock;
   // These locks are the ones waiting for a texture of the right size to come
   // back from the renderer/GPU process.
   std::vector<linked_ptr<ResizeLock> > resize_locks_;
   // These locks are the ones waiting for a frame to be drawn.
   std::vector<linked_ptr<ResizeLock> > locks_pending_draw_;
 
+  // This lock is for waiting for a front surface to become available to draw.
+  scoped_refptr<aura::CompositorLock> released_front_lock_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_