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

content/browser/renderer_host/render_widget_host_view_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/render_widget_host_view_mac.h"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 925 matching lines @@
       !compositing_iosurface_->HasIOSurface())
     return;
 
   float scale = ScaleFactor(cocoa_view_);
   gfx::Size dst_pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(dst_size, scale));
 
   scoped_callback_runner.Release();
 
   compositing_iosurface_->CopyTo(GetScaledOpenGLPixelRect(src_subrect),
-                                 ScaleFactor(cocoa_view_),
                                  dst_pixel_size,
                                  callback);
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
   if (!render_widget_host_->is_accelerated_compositing_active() ||
@@ skipping 11 matching lines @@
     NOTREACHED();
     return;
   }
 
   if (src_subrect.IsEmpty())
     return;
 
   scoped_callback_runner.Release();
   compositing_iosurface_->CopyToVideoFrame(
       GetScaledOpenGLPixelRect(src_subrect),
-      ScaleFactor(cocoa_view_),
       target,
       callback);
 }
 
 bool RenderWidgetHostViewMac::CanCopyToVideoFrame() const {
   return (!render_widget_host_->GetBackingStore(false) &&
           render_widget_host_->is_accelerated_compositing_active() &&
           compositing_iosurface_.get() &&
           compositing_iosurface_->HasIOSurface());
 }
@@ skipping 50 matching lines @@
 
 void RenderWidgetHostViewMac::PluginImeCompositionCompleted(
     const string16& text, int plugin_id) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
 bool RenderWidgetHostViewMac::CompositorSwapBuffers(uint64 surface_handle,
-                                                    const gfx::Size& size) {
+                                                    const gfx::Size& size,
+                                                    float scale_factor) {
   if (is_hidden_)
     return true;
 
   NSWindow* window = [cocoa_view_ window];
   if (window_number() <= 0) {
     // There is no window to present so capturing during present won't work.
     // We check if frame subscriber wants this frame and capture manually.
     if (compositing_iosurface_.get() && 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)) {
-        compositing_iosurface_->SetIOSurface(surface_handle, size);
+        compositing_iosurface_->SetIOSurface(
+            surface_handle, size, scale_factor);
         compositing_iosurface_->CopyToVideoFrame(
-            gfx::Rect(size), ScaleFactor(cocoa_view_), frame,
+            gfx::Rect(size), frame,
             base::Bind(callback, present_time));
         return true;
       }
     }
 
     // TODO(shess) If the view does not have a window, or the window
     // does not have backing, the IOSurface will log "invalid drawable"
     // in -setView:.  It is not clear how this code is reached with such
     // a case, so record some info into breakpad (some subset of
     // browsers are likely to crash later for unrelated reasons).
@@ skipping 19 matching lines @@
         CompositingIOSurfaceMac::SURFACE_ORDER_BELOW_WINDOW :
         CompositingIOSurfaceMac::SURFACE_ORDER_ABOVE_WINDOW;
     compositing_iosurface_.reset(
         CompositingIOSurfaceMac::Create(window_number(), order));
     should_post_notification = true;
   }
 
   if (!compositing_iosurface_)
     return true;
 
-  compositing_iosurface_->SetIOSurface(surface_handle, size);
+  compositing_iosurface_->SetIOSurface(surface_handle, size, scale_factor);
 
   GotAcceleratedFrame();
 
   gfx::Size window_size(NSSizeToCGSize([cocoa_view_ frame].size));
   if (window_size.IsEmpty()) {
     // setNeedsDisplay will never display and we'll never ack if the window is
     // empty, so ack now and don't bother calling setNeedsDisplay below.
     return true;
   }
 
@@ skipping 189 matching lines @@
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
                                                       gpu_host_id));
 
-  if (CompositorSwapBuffers(params.surface_handle, params.size))
+  if (CompositorSwapBuffers(params.surface_handle,
+                            params.size,
+                            params.scale_factor))
     AckPendingSwapBuffers();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
                                                       gpu_host_id));
 
-  if (CompositorSwapBuffers(params.surface_handle, params.surface_size))
+  if (CompositorSwapBuffers(params.surface_handle,
+                            params.surface_size,
+                            params.surface_scale_factor))
     AckPendingSwapBuffers();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_)
     compositing_iosurface_->UnrefIOSurface();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
   compositing_iosurface_.reset();
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
-  // Update device scale factor for the IOSurface before checking if there
-  // is a match. When initially created, the IOSurface is unaware of its
-  // scale factor, which can result in compatible IOSurfaces not being used
-  // http://crbug.com/237293
-  if (compositing_iosurface_.get() &&
-      compositing_iosurface_->HasIOSurface()) {
-    compositing_iosurface_->SetDeviceScaleFactor(ScaleFactor(cocoa_view_));
-  }
-
   return last_frame_was_accelerated_ &&
          compositing_iosurface_.get() &&
          compositing_iosurface_->HasIOSurface() &&
          (desired_size.IsEmpty() ||
-          compositing_iosurface_->io_surface_size() == desired_size);
+          compositing_iosurface_->dip_io_surface_size() == desired_size);
 }
 
 void RenderWidgetHostViewMac::AboutToWaitForBackingStoreMsg() {
   AckPendingSwapBuffers();
 }
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
 }
 
 void RenderWidgetHostViewMac::GetScreenInfo(WebKit::WebScreenInfo* results) {
@@ skipping 2032 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end