Add a path to use CALayers to display content

content/browser/renderer_host/compositing_iosurface_mac.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_COMPOSITING_IOSURFACE_MAC_H_
 #define CONTENT_BROWSER_RENDERER_HOST_COMPOSITING_IOSURFACE_MAC_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 19 matching lines @@
 namespace gfx {
 class Rect;
 }
 
 namespace content {
 
 class CompositingIOSurfaceContext;
 class CompositingIOSurfaceShaderPrograms;
 class CompositingIOSurfaceTransformer;
 class RenderWidgetHostViewFrameSubscriber;
+class RenderWidgetHostViewMac;
 
 // This class manages an OpenGL context and IOSurface for the accelerated
 // compositing code path. The GL context is attached to
 // RenderWidgetHostViewCocoa for blitting the IOSurface.
 class CompositingIOSurfaceMac {
  public:
   // Passed to Create() to specify the ordering of the surface relative to the
   // containing window.
   enum SurfaceOrder {
     SURFACE_ORDER_ABOVE_WINDOW = 0,
     SURFACE_ORDER_BELOW_WINDOW = 1,
   };
 
   // Returns NULL if IOSurface support is missing or GL APIs fail. Specify in
   // |order| the desired ordering relationship of the surface to the containing
   // window.
   static CompositingIOSurfaceMac* Create(int window_number,
                                          SurfaceOrder order);
+  static CompositingIOSurfaceMac* Create(
+      const scoped_refptr<CompositingIOSurfaceContext>& context);
   ~CompositingIOSurfaceMac();
 
   // Set IOSurface that will be drawn on the next NSView drawRect.
   void SetIOSurface(uint64 io_surface_handle,
                     const gfx::Size& size,
                     float scale_factor);
 
   // Get the CGL renderer ID currently associated with this context.
   int GetRendererID();
 
-  // Blit the IOSurface at the upper-left corner of the |view|. If |view| window
-  // size is larger than the IOSurface, the remaining right and bottom edges
-  // will be white. |scaleFactor| is 1 in normal views, 2 in HiDPI views.
-  // |frame_subscriber| listens to this draw event and provides output buffer
-  // for copying this frame into.
-  void DrawIOSurface(NSView* view,
-                     float scale_factor,
-                     int window_number,
-                     SurfaceOrder surface_order,
+  // Blit the IOSurface at the upper-left corner of the of the specified
+  // window_size. If the window size is larger than the IOSurface, the
+  // remaining right and bottom edges will be white. |scaleFactor| is 1
+  // in normal views, 2 in HiDPI views.  |frame_subscriber| listens to
+  // this draw event and provides output buffer for copying this frame into.
+  void DrawIOSurface(const gfx::Size& window_size,
+                     float window_scale_factor,
                      RenderWidgetHostViewFrameSubscriber* frame_subscriber);
+  void DrawIOSurface(RenderWidgetHostViewMac* render_widget_host_view);
 
   // Copy the data of the "live" OpenGL texture referring to this IOSurfaceRef
   // into |out|. The copied region is specified with |src_pixel_subrect| and
   // the data is transformed so that it fits in |dst_pixel_size|.
   // |src_pixel_subrect| and |dst_pixel_size| are not in DIP but in pixel.
   // Caller must ensure that |out| is allocated to dimensions that match
   // dst_pixel_size, with no additional padding.
   // |callback| is invoked when the operation is completed or failed.
   // Do no call this method again before |callback| is invoked.
   void CopyTo(const gfx::Rect& src_pixel_subrect,
@@ skipping 18 matching lines @@
   // this to switch to software drawing mode.
   void ClearDrawable();
 
   bool HasIOSurface() { return !!io_surface_.get(); }
 
   const gfx::Size& pixel_io_surface_size() const {
     return pixel_io_surface_size_;
   }
   // In cocoa view units / DIPs.
   const gfx::Size& dip_io_surface_size() const { return dip_io_surface_size_; }
+  float scale_factor() const { return scale_factor_; }
 
   bool is_vsync_disabled() const;
 
+  const scoped_refptr<CompositingIOSurfaceContext>& context() {
+    return context_;
+  }
+
   // Get vsync scheduling parameters.
   // |interval_numerator/interval_denominator| equates to fractional number of
   // seconds between vsyncs.
   void GetVSyncParameters(base::TimeTicks* timebase,
                           uint32* interval_numerator,
                           uint32* interval_denominator);
 
   // Returns true if asynchronous readback is supported on this system.
   bool IsAsynchronousReadbackSupported();
 
@@ skipping 86 matching lines @@
     GLuint frame_buffers[3];
     GLuint pixel_buffers[3];
     GLuint fence;  // When non-zero, doing an asynchronous copy.
     int cycles_elapsed;
     base::Callback<bool(const void*, int)> map_buffer_callback;
     base::Callback<void(bool)> done_callback;
   };
 
   CompositingIOSurfaceMac(
       IOSurfaceSupport* io_surface_support,
-      scoped_refptr<CompositingIOSurfaceContext> context);
+      const scoped_refptr<CompositingIOSurfaceContext>& context);
 
   void SetupCVDisplayLink();
 
   // If this IOSurface has moved to a different window, use that window's
   // GL context (if multiple visible windows are using the same GL context
   // then call to setView call can stall and prevent reaching 60fps).
   void SwitchToContextOnNewWindow(NSView* view,
                                   int window_number,
                                   SurfaceOrder surface_order);
 
@@ skipping 72 matching lines @@
   // moving between windows, but will never be NULL.
   scoped_refptr<CompositingIOSurfaceContext> context_;
 
   // IOSurface data.
   uint64 io_surface_handle_;
   base::mac::ScopedCFTypeRef<CFTypeRef> io_surface_;
 
   // The width and height of the io surface.
   gfx::Size pixel_io_surface_size_;  // In pixels.
   gfx::Size dip_io_surface_size_;  // In view / density independent pixels.
+  float scale_factor_;
 
   // The "live" OpenGL texture referring to this IOSurfaceRef. Note
   // that per the CGLTexImageIOSurface2D API we do not need to
   // explicitly update this texture's contents once created. All we
   // need to do is ensure it is re-bound before attempting to draw
   // with it.
   GLuint texture_;
 
   // A pool of CopyContexts with OpenGL objects ready for re-use.  Prefer to
   // pull one from the pool before creating a new CopyContext.
@@ skipping 24 matching lines @@
   uint32 vsync_interval_denominator_;
 
   bool initialized_is_intel_;
   bool is_intel_;
   GLint screen_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_COMPOSITING_IOSURFACE_MAC_H_