Mac: Enable partial swap

content/common/gpu/image_transport_surface_overlay_mac.mm

 // Copyright 2015 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/common/gpu/image_transport_surface_overlay_mac.h"
 
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/GL.h>
 
 // This type consistently causes problem on Mac, and needs to be dealt with
@@ skipping 46 matching lines @@
 
 class ImageTransportSurfaceOverlayMac::PendingSwap {
  public:
   PendingSwap() : scale_factor(1) {}
   ~PendingSwap() { DCHECK(!gl_fence); }
 
   gfx::Size pixel_size;
   float scale_factor;
   std::vector<ui::LatencyInfo> latency_info;
 
+  // If true, the partial damage rect for the frame.
+  bool use_partial_damage;
+  gfx::Rect pixel_partial_damage_rect;
+
   // The IOSurface with new content for this swap.
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
 
   // A fence object, and the CGL context it was issued in.
   base::ScopedTypeRef<CGLContextObj> cgl_context;
   scoped_ptr<gfx::GLFence> gl_fence;
 
   // The earliest time that this frame may be drawn. A frame is not allowed
   // to draw until a fraction of the way through the vsync interval after its
   // This extra latency is to allow wiggle-room for smoothness.
@@ skipping 21 matching lines @@
 
   // Create the CAContext to send this to the GPU process, and the layer for
   // the context.
   CGSConnectionID connection_id = CGSMainConnectionID();
   ca_context_.reset(
       [[CAContext contextWithCGSConnection:connection_id options:@{}] retain]);
   layer_.reset([[CALayer alloc] init]);
   [layer_ setGeometryFlipped:YES];
   [layer_ setOpaque:YES];
   [ca_context_ setLayer:layer_];
+
+  partial_damage_layer_.reset([[CALayer alloc] init]);
+  [partial_damage_layer_ setOpaque:YES];
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
   FinishAllPendingSwaps();
 }
 
 bool ImageTransportSurfaceOverlayMac::IsOffscreen() {
   return false;
 }
@@ skipping 55 matching lines @@
     new_swap->latest_allowed_draw_time = now +
         base::TimeDelta::FromSecondsD(kMaximumDelayWaitingForFenceInSeconds);
   } else {
     // If we have no display link (because vsync is disabled or because we have
     // not received display parameters yet), immediately attempt to display the
     // surface.
     new_swap->earliest_allowed_draw_time = now;
     new_swap->latest_allowed_draw_time = now;
   }
 
+  // Determine if this will be a full or partial damage, and compute the rects
+  // for the damage.
+  {
+    // Grow the partial damage rect to include the new damage.
+    accumulated_partial_damage_pixel_rect_.Union(pixel_damage_rect);
+    // Compute the fraction of the full layer that has been damaged. If this
+    // fraction is very large (>85%), just damage the full layer, and don't
+    // bother with the partial layer.
+    const double kMaximumFractionOfFullDamage = 0.85;
+    double fraction_of_full_damage =
+        accumulated_partial_damage_pixel_rect_.size().GetArea() /
+            static_cast<double>(pixel_size_.GetArea());
+    // Compute the fraction of the accumulated partial damage rect that has been
+    // damaged. If this gets too small (<75%), just re-damage the full window,
+    // so we can re-create a smaller partial damage layer next frame.
+    const double kMinimumFractionOfPartialDamage = 0.75;
+    double fraction_of_partial_damage =
+        pixel_damage_rect.size().GetArea() / static_cast<double>(
+            accumulated_partial_damage_pixel_rect_.size().GetArea());
+    if (fraction_of_full_damage < kMaximumFractionOfFullDamage &&
+        fraction_of_partial_damage > kMinimumFractionOfPartialDamage) {
+      new_swap->use_partial_damage = true;
+      new_swap->pixel_partial_damage_rect =
+          accumulated_partial_damage_pixel_rect_;
+    } else {
+      new_swap->use_partial_damage = false;
+      accumulated_partial_damage_pixel_rect_ = gfx::Rect();
+    }
+  }
+
   pending_swaps_.push_back(new_swap);
   PostCheckPendingSwapsCallbackIfNeeded(now);
   return gfx::SwapResult::SWAP_ACK;
 }
 
 bool ImageTransportSurfaceOverlayMac::IsFirstPendingSwapReadyToDisplay(
     const base::TimeTicks& now) {
   DCHECK(!pending_swaps_.empty());
   linked_ptr<PendingSwap> swap = pending_swaps_.front();
 
@@ skipping 46 matching lines @@
     CheckGLErrors("while deleting active fence");
   }
 
   // Update the CALayer hierarchy.
   {
     TRACE_EVENT1("gpu", "ImageTransportSurfaceOverlayMac::setContents",
                  "surface", swap->io_surface.get());
     ScopedCAActionDisabler disabler;
 
     id new_contents = static_cast<id>(swap->io_surface.get());
-    [layer_ setContents:new_contents];
+    if (swap->use_partial_damage) {
+      if (![partial_damage_layer_ superlayer])
+        [layer_ addSublayer:partial_damage_layer_];
+      [partial_damage_layer_ setContents:new_contents];
 
-    CGRect new_frame = gfx::ConvertRectToDIP(
-        swap->scale_factor, gfx::Rect(swap->pixel_size)).ToCGRect();
-    if (!CGRectEqualToRect([layer_ frame], new_frame))
-      [layer_ setFrame:new_frame];
+      CGRect new_frame = gfx::ConvertRectToDIP(
+          swap->scale_factor, swap->pixel_partial_damage_rect).ToCGRect();
+      if (!CGRectEqualToRect([partial_damage_layer_ frame], new_frame))
+        [partial_damage_layer_ setFrame:new_frame];
+
+      gfx::RectF contents_rect =
+          gfx::RectF(swap->pixel_partial_damage_rect);
+      contents_rect.Scale(
+          1. / swap->pixel_size.width(), 1. / swap->pixel_size.height());
+      CGRect cg_contents_rect = CGRectMake(
+          contents_rect.x(), contents_rect.y(),
+          contents_rect.width(), contents_rect.height());
+      [partial_damage_layer_ setContentsRect:cg_contents_rect];
+    } else {
+      // Remove the partial damage layer.
+      if ([partial_damage_layer_ superlayer]) {
+        [partial_damage_layer_ removeFromSuperlayer];
+        [partial_damage_layer_ setContents:nil];
+      }
+
+      // Note that calling setContents with the same IOSurface twice will result
+      // in the screen not being updated, even if the IOSurface's content has
+      // changed. Avoid this by calling setContentsChanged.
+      if ([layer_ contents] == new_contents)
+        [layer_ setContentsChanged];
+      else
+        [layer_ setContents:new_contents];
+
+      CGRect new_frame = gfx::ConvertRectToDIP(
+          swap->scale_factor, gfx::Rect(swap->pixel_size)).ToCGRect();
+      if (!CGRectEqualToRect([layer_ frame], new_frame))
+        [layer_ setFrame:new_frame];
+    }
   }
 
   // Send acknowledgement to the browser.
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_handle =
       ui::SurfaceHandleFromCAContextID([ca_context_ contextId]);
   params.size = pixel_size_;
   params.scale_factor = scale_factor_;
   params.latency_info.swap(swap->latency_info);
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
@@ skipping 114 matching lines @@
 
 void ImageTransportSurfaceOverlayMac::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   latency_info_.insert(
       latency_info_.end(), latency_info.begin(), latency_info.end());
 }
 
 void ImageTransportSurfaceOverlayMac::WakeUpGpu() {}
 
 }  // namespace content