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;
+  dip_io_surface_size_ = gfx::ToFlooredSize(
+      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor));
   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_);
+  quad.set_size(dip_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.
+  // window_size / dip_io_surface_size_ (as opposed to the pixel_ variants)
+  // below is correct.
   glOrtho(0, window_size.width(), window_size.height(), 0, -1, 1);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
 
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_BLEND);
 
   if (has_io_surface) {
     context_->shader_program_cache()->UseBlitProgram();
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture_);
 
     DrawQuad(quad);
 
     glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0); CHECK_GL_ERROR();
 
     // Fill the resize gutters with white.
-    if (window_size.width() > io_surface_size_.width() ||
-        window_size.height() > io_surface_size_.height()) {
+    if (window_size.width() > dip_io_surface_size_.width() ||
+        window_size.height() > dip_io_surface_size_.height()) {
       context_->shader_program_cache()->UseSolidWhiteProgram();
       SurfaceQuad filler_quad;
-      if (window_size.width() > io_surface_size_.width()) {
+      if (window_size.width() > dip_io_surface_size_.width()) {
         // Draw right-side gutter down to the bottom of the window.
-        filler_quad.set_rect(io_surface_size_.width(), 0.0f,
+        filler_quad.set_rect(dip_io_surface_size_.width(), 0.0f,
                              window_size.width(), window_size.height());
         DrawQuad(filler_quad);
       }
-      if (window_size.height() > io_surface_size_.height()) {
+      if (window_size.height() > dip_io_surface_size_.height()) {
         // Draw bottom gutter to the width of the IOSurface.
-        filler_quad.set_rect(0.0f, io_surface_size_.height(),
-                             io_surface_size_.width(), window_size.height());
+        filler_quad.set_rect(
+            0.0f, dip_io_surface_size_.height(),
+            dip_io_surface_size_.width(), window_size.height());
         DrawQuad(filler_quad);
       }
     }
 
     // Workaround for issue 158469. Issue a dummy draw call with texture_ not
     // bound to blit_rgb_sampler_location_, in order to shake all references
     // to the IOSurface out of the driver.
     glBegin(GL_TRIANGLES);
     glEnd();
 
@@ skipping 31 matching lines @@
     glFinish();
   }
 
   base::Closure copy_done_callback;
   if (frame_subscriber) {
     const base::Time present_time = base::Time::Now();
     scoped_refptr<media::VideoFrame> frame;
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     if (frame_subscriber->ShouldCaptureFrame(present_time, &frame, &callback)) {
       copy_done_callback = CopyToVideoFrameWithinContext(
-          gfx::Rect(pixel_io_surface_size_), scale_factor, true, frame,
+          gfx::Rect(pixel_io_surface_size_), true, frame,
           base::Bind(callback, present_time));
     }
   }
 
   CGLFlushDrawable(context_->cgl_context());
 
   // For latency_tests.cc:
   UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete",
                                  TRACE_EVENT_SCOPE_THREAD);
 
   // Try to finish previous copy requests after flush to get better pipelining.
   std::vector<base::Closure> copy_done_callbacks;
   FinishAllCopiesWithinContext(&copy_done_callbacks);
 
   CGLSetCurrentContext(0);
 
   if (!copy_done_callback.is_null())
     copy_done_callbacks.push_back(copy_done_callback);
   for (size_t i = 0; i < copy_done_callbacks.size(); ++i)
     copy_done_callbacks[i].Run();
 
   StartOrContinueDisplayLink();
 
   if (!is_vsync_disabled())
     RateLimitDraws();
 }
 
 void CompositingIOSurfaceMac::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) {
   scoped_ptr<SkBitmap> output(new SkBitmap());
   output->setConfig(SkBitmap::kARGB_8888_Config,
                     dst_pixel_size.width(), dst_pixel_size.height());
   if (!output->allocPixels()) {
     DLOG(ERROR) << "Failed to allocate SkBitmap pixels!";
     callback.Run(false, *output);
     return;
   }
   DCHECK_EQ(output->rowBytesAsPixels(), dst_pixel_size.width())
       << "Stride is required to be equal to width for GPU readback.";
   output->setIsOpaque(true);
 
   CGLSetCurrentContext(context_->cgl_context());
   const base::Closure copy_done_callback = CopyToSelectedOutputWithinContext(
-      src_pixel_subrect, src_scale_factor, gfx::Rect(dst_pixel_size), false,
+      src_pixel_subrect, gfx::Rect(dst_pixel_size), false,
       output.get(), NULL,
       base::Bind(&ReverseArgumentOrder, callback, base::Passed(&output)));
   CGLSetCurrentContext(0);
   if (!copy_done_callback.is_null())
     copy_done_callback.Run();
 }
 
 void CompositingIOSurfaceMac::CopyToVideoFrame(
     const gfx::Rect& src_pixel_subrect,
-    float src_scale_factor,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   CGLSetCurrentContext(context_->cgl_context());
   const base::Closure copy_done_callback = CopyToVideoFrameWithinContext(
-      src_pixel_subrect, src_scale_factor, false, target, callback);
+      src_pixel_subrect, false, target, callback);
   CGLSetCurrentContext(0);
   if (!copy_done_callback.is_null())
     copy_done_callback.Run();
 }
 
 base::Closure CompositingIOSurfaceMac::CopyToVideoFrameWithinContext(
     const gfx::Rect& src_pixel_subrect,
-    float src_scale_factor,
     bool called_within_draw,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   gfx::Rect region_in_frame = media::ComputeLetterboxRegion(
       gfx::Rect(target->coded_size()), src_pixel_subrect.size());
   // Make coordinates and sizes even because we letterbox in YUV space right
   // now (see CopyRGBToVideoFrame). They need to be even for the UV samples to
   // line up correctly.
   region_in_frame = gfx::Rect(region_in_frame.x() & ~1,
                               region_in_frame.y() & ~1,
                               region_in_frame.width() & ~1,
                               region_in_frame.height() & ~1);
   DCHECK(!region_in_frame.IsEmpty());
   DCHECK_LE(region_in_frame.right(), target->coded_size().width());
   DCHECK_LE(region_in_frame.bottom(), target->coded_size().height());
 
   return CopyToSelectedOutputWithinContext(
-      src_pixel_subrect, src_scale_factor, region_in_frame, called_within_draw,
+      src_pixel_subrect, region_in_frame, called_within_draw,
       NULL, target, callback);
 }
 
 bool CompositingIOSurfaceMac::MapIOSurfaceToTexture(
     uint64 io_surface_handle) {
   if (io_surface_.get() && io_surface_handle == io_surface_handle_)
     return true;
 
   TRACE_EVENT0("browser", "CompositingIOSurfaceMac::MapIOSurfaceToTexture");
   UnrefIOSurfaceWithContextCurrent();
 
   io_surface_.reset(io_surface_support_->IOSurfaceLookup(
       static_cast<uint32>(io_surface_handle)));
   // Can fail if IOSurface with that ID was already released by the gpu
   // process.
   if (!io_surface_) {
     io_surface_handle_ = 0;
     return false;
   }
 
   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_;
-
   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 141 matching lines @@
   const bool forced_synchronous = CommandLine::ForCurrentProcess()->HasSwitch(
                                       switches::kForceSynchronousGLReadPixels);
   return (!forced_synchronous &&
           HasAppleFenceExtension() &&
           HasPixelBufferObjectExtension() &&
           (base::mac::IsOSMountainLionOrLater() || !IsVendorIntel()));
 }
 
 base::Closure CompositingIOSurfaceMac::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) {
   DCHECK_NE(bitmap_output != NULL, video_frame_output != NULL);
   DCHECK(!done_callback.is_null());
 
   const bool async_copy = IsAsynchronousReadbackSupported();
   TRACE_EVENT2(
@@ skipping 16 matching lines @@
   } else {
     copy_context = copy_context_pool_.back();
     copy_context_pool_.pop_back();
   }
 
   // Set up source texture, bound to the GL_TEXTURE_RECTANGLE_ARB target.
   if (!MapIOSurfaceToTexture(io_surface_handle_))
     return base::Bind(done_callback, false);
 
   // Send transform commands to the GPU.
-  const gfx::Rect src_rect = IntersectWithIOSurface(src_pixel_subrect,
-                                                    src_scale_factor);
+  const gfx::Rect src_rect = IntersectWithIOSurface(src_pixel_subrect);
   copy_context->num_outputs = 0;
   if (bitmap_output) {
     if (copy_context->transformer->ResizeBilinear(
             texture_, src_rect, dst_pixel_rect.size(),
             &copy_context->output_textures[0])) {
       copy_context->num_outputs = 1;
       copy_context->output_texture_sizes[0] = dst_pixel_rect.size();
     }
   } else {
     if (copy_context->transformer->TransformRGBToYV12(
@@ skipping 233 matching lines @@
                             copy_requests_.begin(), copy_requests_.end());
   copy_requests_.clear();
   while (!copy_context_pool_.empty()) {
     scoped_ptr<CopyContext> copy_context(copy_context_pool_.back());
     copy_context_pool_.pop_back();
     copy_context->ReleaseCachedGLObjects();
   }
 }
 
 gfx::Rect CompositingIOSurfaceMac::IntersectWithIOSurface(
-    const gfx::Rect& rect, float scale_factor) const {
+    const gfx::Rect& rect) const {
   return gfx::IntersectRects(rect,
-      gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(io_surface_size_),
-                                          scale_factor)));
+      gfx::ToEnclosingRect(gfx::Rect(pixel_io_surface_size_)));
 }
 
 }  // namespace content