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

content/browser/renderer_host/compositing_iosurface_mac.mm

 // 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.
 
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/OpenGL.h>
 
 #include "base/bind.h"
@@ skipping 317 matching lines @@
   // Having two NSOpenGLContexts bound to an NSView concurrently will cause
   // artifacts and crashes. If |context_| is bound to |view|, then unbind
   // |context_| before |new_context| gets bound to |view|.
   // http://crbug.com/230883
   if ([context_->nsgl_context() view] == view)
     [context_->nsgl_context() clearDrawable];
 
   context_ = new_context;
 }
 
-void CompositingIOSurfaceMac::SetDeviceScaleFactor(float scale_factor) {
-  // TODO: After a resolution change, the DPI-ness of the view and the
-  // IOSurface might not be in sync.
-  io_surface_size_ = gfx::ToFlooredSize(
-      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor));
-}
-
 bool CompositingIOSurfaceMac::is_vsync_disabled() const {
   return context_->is_vsync_disabled();
 }
 
 void CompositingIOSurfaceMac::GetVSyncParameters(base::TimeTicks* timebase,
                                                  uint32* interval_numerator,
                                                  uint32* interval_denominator) {
   base::AutoLock lock(lock_);
   *timebase = vsync_timebase_;
   *interval_numerator = vsync_interval_numerator_;
   *interval_denominator = vsync_interval_denominator_;
 }
 
 CompositingIOSurfaceMac::~CompositingIOSurfaceMac() {
   FailAllCopies();
   CVDisplayLinkRelease(display_link_);
   CGLSetCurrentContext(context_->cgl_context());
   DestroyAllCopyContextsWithinContext();
   UnrefIOSurfaceWithContextCurrent();
   CGLSetCurrentContext(0);
   context_ = nil;
 }
 
 void CompositingIOSurfaceMac::SetIOSurface(uint64 io_surface_handle,
-                                           const gfx::Size& size) {
+                                           const gfx::Size& size,
+                                           float scale_factor) {
   pixel_io_surface_size_ = size;
+  io_surface_size_ = gfx::ToFlooredSize(
+      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor));

[Nico, 2013/05/22 15:33:22]

Does this still have to be a member variable, or can it be a local in
DrawIOSurface() now?

[ccameron, 2013/05/22 20:50:12]

It's also used when checking HasAcceleratedSurface (and if we didn't have to
store it, we'd have to store scale factor, which we skip ATM). I renamed this to
dip_io_surace_size_ to make the units clearer.

   CGLSetCurrentContext(context_->cgl_context());
   MapIOSurfaceToTexture(io_surface_handle);
   CGLSetCurrentContext(0);
 }
 
 int CompositingIOSurfaceMac::GetRendererID() {
   GLint current_renderer_id = -1;
   if (CGLGetParameter(context_->cgl_context(),
                       kCGLCPCurrentRendererID,
                       &current_renderer_id) == kCGLNoError)
@@ skipping 19 matching lines @@
 
   TRACE_EVENT1("browser", "CompositingIOSurfaceMac::DrawIOSurface",
                "has_io_surface", has_io_surface);
 
   [context_->nsgl_context() setView:view];
   gfx::Size window_size(NSSizeToCGSize([view frame].size));
   gfx::Size pixel_window_size = gfx::ToFlooredSize(
       gfx::ScaleSize(window_size, scale_factor));
   glViewport(0, 0, pixel_window_size.width(), pixel_window_size.height());
 
-  SetDeviceScaleFactor(scale_factor);
-
   SurfaceQuad quad;
   quad.set_size(io_surface_size_, pixel_io_surface_size_);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   // Note that the projection keeps things in view units, so the use of
   // window_size / io_surface_size_ (as opposed to the pixel_ variants) below is
   // correct.
   glOrtho(0, window_size.width(), window_size.height(), 0, -1, 1);
@@ skipping 188 matching lines @@
   }
 
   io_surface_handle_ = io_surface_handle;
 
   // Actual IOSurface size is rounded up to reduce reallocations during window
   // resize. Get the actual size to properly map the texture.
   gfx::Size rounded_size(
       io_surface_support_->IOSurfaceGetWidth(io_surface_),
       io_surface_support_->IOSurfaceGetHeight(io_surface_));
 
-  // TODO(thakis): Keep track of the view size over IPC. At the moment,
-  // the correct view units are computed on first paint.
-  io_surface_size_ = pixel_io_surface_size_;

[Nico, 2013/05/22 15:33:22]

\o/

-
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   glGenTextures(1, &texture_);
   glBindTexture(target, texture_);
   glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); CHECK_GL_ERROR();
   GLuint plane = 0;
   CGLError cglerror = io_surface_support_->CGLTexImageIOSurface2D(
       context_->cgl_context(),
       target,
       GL_RGBA,
@@ skipping 440 matching lines @@
 }
 
 gfx::Rect CompositingIOSurfaceMac::IntersectWithIOSurface(
     const gfx::Rect& rect, float scale_factor) const {
   return gfx::IntersectRects(rect,
       gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(io_surface_size_),
                                           scale_factor)));
 }
 
 }  // namespace content