Mac: Add partial swap support to NSOpenGLContext path

ui/accelerated_widget_mac/accelerated_widget_mac.mm

 // Copyright 2014 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 "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 113 matching lines @@
   [io_surface_layer_ beginPumpingFrames];
 }
 
 void AcceleratedWidgetMac::EndPumpingFrames() {
   [io_surface_layer_ endPumpingFrames];
 }
 
 void AcceleratedWidgetMac::GotAcceleratedFrame(
     uint64 surface_handle,
     const std::vector<ui::LatencyInfo>& latency_info,
-    gfx::Size pixel_size, float scale_factor,
+    const gfx::Size& pixel_size,
+    float scale_factor,
+    const gfx::Rect& pixel_damage_rect,
     const base::Closure& drawn_callback) {
   static bool use_ns_gl_surfaces =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNSGLSurfaces);
 
   // Record the surface and latency info to use when acknowledging this frame.
   DCHECK(accelerated_frame_drawn_callback_.is_null());
   accelerated_frame_drawn_callback_ = drawn_callback;
   accelerated_latency_info_.insert(accelerated_latency_info_.end(),
                                    latency_info.begin(), latency_info.end());
 
   // If there is no view and therefore no superview to draw into, early-out.
   if (!view_) {
     AcknowledgeAcceleratedFrame();
     return;
   }
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
   last_swap_size_dip_ = gfx::ConvertSizeToDIP(scale_factor, pixel_size);
   switch (GetSurfaceHandleType(surface_handle)) {
     case kSurfaceHandleTypeIOSurface: {
       IOSurfaceID io_surface_id = IOSurfaceIDFromSurfaceHandle(surface_handle);
       if (use_ns_gl_surfaces) {
         GotAcceleratedIOSurfaceFrameNSGL(
-            io_surface_id, pixel_size, scale_factor);
+            io_surface_id, pixel_size, scale_factor, pixel_damage_rect);
       } else {
         GotAcceleratedIOSurfaceFrame(io_surface_id, pixel_size, scale_factor);
       }
       break;
     }
     case kSurfaceHandleTypeCAContext: {
       CAContextID ca_context_id = CAContextIDFromSurfaceHandle(surface_handle);
       GotAcceleratedCAContextFrame(ca_context_id, pixel_size, scale_factor);
       break;
     }
     default:
       LOG(ERROR) << "Unrecognized accelerated frame type.";
       return;
   }
 }
 
 void AcceleratedWidgetMac::GotAcceleratedCAContextFrame(
     CAContextID ca_context_id,
-    gfx::Size pixel_size,
+    const gfx::Size& pixel_size,
     float scale_factor) {
   // In the layer is replaced, keep the old one around until after the new one
   // is installed to avoid flashes.
   base::scoped_nsobject<CALayerHost> old_ca_context_layer =
       ca_context_layer_;
 
   // Create the layer to host the layer exported by the GPU process with this
   // particular CAContext ID.
   if ([ca_context_layer_ contextId] != ca_context_id) {
     ca_context_layer_.reset([[CALayerHost alloc] init]);
@@ skipping 11 matching lines @@
   // in the hierarchy.
   if (old_ca_context_layer != ca_context_layer_)
     DestroyCAContextLayer(old_ca_context_layer);
 
   // Remove any different-type layers that this is replacing.
   DestroyIOSurfaceLayer(io_surface_layer_);
   DestroySoftwareLayer();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedIOSurfaceFrameNSGL(
-    IOSurfaceID io_surface_id, gfx::Size pixel_size, float scale_factor) {
+    IOSurfaceID io_surface_id,
+    const gfx::Size& pixel_size,
+    float scale_factor,
+    const gfx::Rect& pixel_damage_rect) {
   if (!io_surface_ns_gl_surface_) {
     io_surface_ns_gl_surface_.reset(
         IOSurfaceNSGLSurface::Create(view_->AcceleratedWidgetGetNSView()));
   }
 
   if (!io_surface_ns_gl_surface_) {
     LOG(ERROR) << "Failed to create IOSurfaceNSGLSurface";
     AcknowledgeAcceleratedFrame();
     return;
   }
 
-  io_surface_ns_gl_surface_->GotFrame(io_surface_id, pixel_size, scale_factor);
+  io_surface_ns_gl_surface_->GotFrame(
+      io_surface_id, pixel_size, scale_factor, pixel_damage_rect);
   AcknowledgeAcceleratedFrame();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedIOSurfaceFrame(
     IOSurfaceID io_surface_id,
-    gfx::Size pixel_size,
+    const gfx::Size& pixel_size,
     float scale_factor) {
   // In the layer is replaced, keep the old one around until after the new one
   // is installed to avoid flashes.
   base::scoped_nsobject<IOSurfaceLayer> old_io_surface_layer =
       io_surface_layer_;
 
   // Create or re-create an IOSurface layer if needed. If there already exists
   // a layer but it has the wrong scale factor or it was poisoned, re-create the
   // layer.
   bool needs_new_layer =
@@ skipping 141 matching lines @@
   // Poison the context being used and request a mulligan.
   [io_surface_layer_ poisonContextAndSharegroup];
 
   if (view_)
     view_->AcceleratedWidgetHitError();
 }
 
 void AcceleratedWidgetMacGotAcceleratedFrame(
     gfx::AcceleratedWidget widget, uint64 surface_handle,
     const std::vector<ui::LatencyInfo>& latency_info,
-    gfx::Size pixel_size, float scale_factor,
+    const gfx::Size& pixel_size,
+    float scale_factor,
+    const gfx::Rect& pixel_damage_rect,
     const base::Closure& drawn_callback,
     bool* disable_throttling, int* renderer_id) {
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
   if (accelerated_widget_mac) {
     accelerated_widget_mac->GotAcceleratedFrame(
-        surface_handle, latency_info, pixel_size, scale_factor, drawn_callback);
+        surface_handle, latency_info, pixel_size, scale_factor,
+        pixel_damage_rect, drawn_callback);
     *disable_throttling =
         accelerated_widget_mac->IsRendererThrottlingDisabled();
     *renderer_id = accelerated_widget_mac->GetRendererID();
   } else {
     *disable_throttling = false;
     *renderer_id = 0;
   }
 }
 
 void AcceleratedWidgetMacGotSoftwareFrame(
     gfx::AcceleratedWidget widget, float scale_factor, SkCanvas* canvas) {
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
   if (accelerated_widget_mac)
     accelerated_widget_mac->GotSoftwareFrame(scale_factor, canvas);
 }
 
 }  // namespace ui