Aura: Have ui::Layer implement WebKit::WebExternalTextureLayerClient

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>
 
@@ skipping 18 matching lines @@
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 }
 
 namespace gfx {
 class Canvas;
 }
 
 namespace ui {
 class InputMethod;
+class Texture;
 }
 
 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:
   // RenderWidgetHostView implementation.
@@ skipping 130 matching lines @@
   friend class content::RenderWidgetHostView;
 
   // Should construct only via RenderWidgetHostView::CreateViewForWidget.
   explicit RenderWidgetHostViewAura(content::RenderWidgetHost* host);
 
  private:
   class WindowObserver;
   friend class WindowObserver;
 
   // Overridden from ui::CompositorObserver:
+  virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingWillStart(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingStarted(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE;
 
   // Overridden from ImageTransportFactoryObserver:
   virtual void OnLostResources(ui::Compositor* compositor) OVERRIDE;
 
   virtual ~RenderWidgetHostViewAura();
 
@@ skipping 14 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 RunCompositingCallbacks();
+  void RunCompositingDidCommitCallbacks(ui::Compositor* compositor);
+  void RunCompositingWillStartCallbacks(ui::Compositor* compositor);
 
   // Insert a sync point into the compositor's command stream and acknowledge
   // that we have presented the accelerated surface buffer.
-  void InsertSyncPointAndACK(int32 route_id, int gpu_host_id);
+  static void InsertSyncPointAndACK(int32 route_id,
+                                    int gpu_host_id,
+                                    ui::Compositor* compositor);
 
   // Called when window_ is removed from the window tree.
   void RemovingFromRootWindow();
 
   ui::Compositor* GetCompositor();
 
   // Detaches |this| from the input method object.
   void DetachFromInputMethod();
 
   // Converts |rect| from window coordinate to screen coordinate.
@@ skipping 41 matching lines @@
 
   // The current composition character bounds.
   std::vector<gfx::Rect> composition_character_bounds_;
 
   // Indicates if there is onging composition text.
   bool has_composition_text_;
 
   // Current tooltip text.
   string16 tooltip_;
 
-  std::vector< base::Callback<void(void)> >
+  std::vector< base::Callback<void(ui::Compositor*)> >
+      on_compositing_did_commit_callbacks_;
+
+  std::vector< base::Callback<void(ui::Compositor*)> >
       on_compositing_will_start_callbacks_;
 
-  std::map<uint64, scoped_refptr<ImageTransportClient> >
+  std::map<uint64, scoped_refptr<ui::Texture> >
       image_transport_clients_;
 
   uint64 current_surface_;
 
   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.
@@ skipping 24 matching lines @@
   // 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_