Part 3/3 (RWH/IOSurface) of adding with device scale factor to transport surfaces

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 41 matching lines @@
 
   // 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);
   ~CompositingIOSurfaceMac();
 
   // Set IOSurface that will be drawn on the next NSView drawRect.
   void SetIOSurface(uint64 io_surface_handle,
-                    const gfx::Size& size);
+                    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,
                      RenderWidgetHostViewFrameSubscriber* frame_subscriber);
 
   // 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,
-              float src_scale_factor,
               const gfx::Size& dst_pixel_size,
               const base::Callback<void(bool, const SkBitmap&)>& callback);
 
   // Transfer the contents of the surface to an already-allocated YV12
   // VideoFrame, and invoke a callback to indicate success or failure.
   void CopyToVideoFrame(
       const gfx::Rect& src_subrect,
-      float src_scale_factor,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback);
 
   // Unref the IOSurface and delete the associated GL texture. If the GPU
   // process is no longer referencing it, this will delete the IOSurface.
   void UnrefIOSurface();
 
   // Call when globalFrameDidChange is received on the NSView.
   void GlobalFrameDidChange();
 
   // Disassociate the GL context with the NSView and unref the IOSurface. Do
   // 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& io_surface_size() const { return io_surface_size_; }
-
-  void SetDeviceScaleFactor(float scale_factor);
+  const gfx::Size& dip_io_surface_size() const { return dip_io_surface_size_; }
 
   bool is_vsync_disabled() const;
 
   // 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);
 
@@ skipping 129 matching lines @@
   void StartOrContinueDisplayLink();
   void StopDisplayLink();
 
   // Copy current frame to |target| video frame. This method must be called
   // within a CGL context. Returns a callback that should be called outside
   // of the CGL context.
   // If |called_within_draw| is true this method is called within a drawing
   // operations. This allow certain optimizations.
   base::Closure CopyToVideoFrameWithinContext(
       const gfx::Rect& src_subrect,
-      float src_scale_factor,
       bool called_within_draw,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback);
 
   // Common GPU-readback copy path.  Only one of |bitmap_output| or
   // |video_frame_output| may be specified: Either ARGB is written to
   // |bitmap_output| or letter-boxed YV12 is written to |video_frame_output|.
   base::Closure CopyToSelectedOutputWithinContext(
       const gfx::Rect& src_pixel_subrect,
-      float src_scale_factor,
       const gfx::Rect& dst_pixel_rect,
       bool called_within_draw,
       const SkBitmap* bitmap_output,
       const scoped_refptr<media::VideoFrame>& video_frame_output,
       const base::Callback<void(bool)>& done_callback);
 
   // TODO(hclam): These two methods should be static.
   void AsynchronousReadbackForCopy(
       const gfx::Rect& dst_pixel_rect,
       bool called_within_draw,
       CopyContext* copy_context,
       const SkBitmap* bitmap_output,
       const scoped_refptr<media::VideoFrame>& video_frame_output);
   bool SynchronousReadbackForCopy(
       const gfx::Rect& dst_pixel_rect,
       CopyContext* copy_context,
       const SkBitmap* bitmap_output,
       const scoped_refptr<media::VideoFrame>& video_frame_output);
 
   // Scan the list of started asynchronous copies and test if each one has
   // completed.
   void FinishAllCopies();
   void FinishAllCopiesWithinContext(
       std::vector<base::Closure>* done_callbacks);
 
   void FailAllCopies();
   void DestroyAllCopyContextsWithinContext();
 
-  gfx::Rect IntersectWithIOSurface(const gfx::Rect& rect,
-                                   float scale_factor) const;
+  gfx::Rect IntersectWithIOSurface(const gfx::Rect& rect) const;
 
   // Cached pointer to IOSurfaceSupport Singleton.
   IOSurfaceSupport* io_surface_support_;
 
   // GL context, and parameters for context sharing. This may change when
   // 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 io_surface_size_;  // In view units.
+  gfx::Size dip_io_surface_size_;  // In view / density independent pixels.
 
   // 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_