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 <OpenGL/gl.h>
 #include <OpenGL/glext.h>
 
 #include "content/common/gpu/gpu_messages.h"
 #include "ui/accelerated_widget_mac/surface_handle_types.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/base/cocoa/remote_layer_api.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gl/gl_image_io_surface.h"
 #include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_cgl.h"
 
 #define LOG_GL_ERRORS(msg) \
   do { \
     for (GLenum gl_error = glGetError(); gl_error != GL_NO_ERROR; \
          gl_error = glGetError()) { \
       LOG(ERROR) << "OpenGL error hit " << msg << ": " << gl_error; \
     } \
   } while (0)
 
+@interface CALayer(Private)
+-(void) setContentsChanged;

[Andre, 2015/08/05 17:59:30]

- (void)set...

[ccameron, 2015/08/06 18:55:18]

Done.

+@end
+
 namespace content {
 
 ImageTransportSurfaceOverlayMac::ImageTransportSurfaceOverlayMac(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::PluginWindowHandle handle)
     : scale_factor_(1), pending_overlay_image_(nullptr), weak_factory_(this) {
   helper_.reset(new ImageTransportHelper(this, manager, stub, handle));
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
 }
 
 bool ImageTransportSurfaceOverlayMac::Initialize() {
   if (!helper_->Initialize())
     return false;
 
   // 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];
+  partial_damage_layer_.reset([[CALayer alloc] init]);
   [ca_context_ setLayer:layer_];
 
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
   CheckAndDisplayPendingSwaps(true);
 }
 
 bool ImageTransportSurfaceOverlayMac::IsOffscreen() {
@@ skipping 25 matching lines @@
                  this_swap.io_surface.get());
     LOG_GL_ERRORS("before flushing frame");
     this_swap.cgl_context.reset(CGLGetCurrentContext(),
                                 base::scoped_policy::RETAIN);
     glGenFencesAPPLE(1, &this_swap.fence);
     glSetFenceAPPLE(this_swap.fence);
     glFlush();
     LOG_GL_ERRORS("while flushing frame");
   }
 
-  this_swap.dip_size = gfx::ConvertSizeToDIP(scale_factor_, pixel_size_);
+  // Determine if this will be a full or partial damage, and compute the rects
+  // for the damage.
+  {
+    this_swap.dip_size = gfx::ConvertSizeToDIP(scale_factor_, pixel_size_);
+
+    // 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.
+    double kMaximumFractionOfFullDamage = 0.85;

[Andre, 2015/08/05 17:59:30]

nit: const

[ccameron, 2015/08/06 18:55:18]

Done.

+    double fraction_of_full_damage =

[Andre, 2015/08/05 17:59:30]

nit: const

[ccameron, 2015/08/06 18:55:18]

Done.

+        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.
+    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) {
+      this_swap.use_partial_damage = true;
+      this_swap.dip_partial_damage_rect = gfx::ConvertRectToDIP(
+          scale_factor_, accumulated_partial_damage_pixel_rect_);
+    } else {
+      this_swap.use_partial_damage = false;
+      accumulated_partial_damage_pixel_rect_ = gfx::Rect();
+    }
+  }
+
   pending_swaps_.push_back(this_swap);
-
   PostCheckAndDisplayPendingSwaps();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 void ImageTransportSurfaceOverlayMac::CheckAndDisplayPendingSwaps(
     bool force_immediate_display) {
   TRACE_EVENT0("gpu",
                "ImageTransportSurfaceOverlayMac::CheckAndDisplayPendingSwaps");
   if (pending_swaps_.empty())
     return;
@@ skipping 15 matching lines @@
     }
     glDeleteFencesAPPLE(1, &this_swap.fence);
     LOG_GL_ERRORS("while deleting fence");
   }
 
   // Update the CALayer hierarchy.
   {
     TRACE_EVENT1("gpu", "ImageTransportSurfaceOverlayMac::setContents",
                  "surface", this_swap.io_surface.get());
     ScopedCAActionDisabler disabler;
-    id new_contents = static_cast<id>(this_swap.io_surface.get());
-    [layer_ setContents:new_contents];
-    [layer_ setFrame:gfx::Rect(this_swap.dip_size).ToCGRect()];
+    if (this_swap.use_partial_damage) {
+      if (![partial_damage_layer_ superlayer])
+        [layer_ addSublayer:partial_damage_layer_];
+
+      [partial_damage_layer_
+          setContents:static_cast<id>(this_swap.io_surface.get())];
+      [partial_damage_layer_
+          setFrame:this_swap.dip_partial_damage_rect.ToCGRect()];
+      gfx::RectF content_bounds_rect =
+          gfx::RectF(this_swap.dip_partial_damage_rect);
+      content_bounds_rect.Scale(
+          1. / this_swap.dip_size.width(), 1. / this_swap.dip_size.height());
+      [partial_damage_layer_ setContentsRect:CGRectMake(
+          content_bounds_rect.x(),
+          content_bounds_rect.y(),
+          content_bounds_rect.width(),
+          content_bounds_rect.height())];

[Andre, 2015/08/05 17:59:30]

How about something like:
CGRect damage_rect = this_swap.dip_partial_damage_rect.ToCGRect();
[partial_damage_layer_ setFrame:damage_rect];
[partial_damage_layer_ setContentsRect:
    CGRectApplyAffineTransform(damage_rect, CGAffineTransformMakeScale(
        1. / damage_rect.size.width, 1. / damage_rect.size.height));];

Also, I feel like using a shorter name like damage_layer_ instead of
partial_damage_layer_ might make this
code more readable. WDYT?

[ccameron, 2015/08/06 18:55:18]

Actually, gfx::RectF should have a ToCGRect function, so I added that (so that
we only go to the CG types at the last minute).

+    } else {
+      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.
+      id new_contents = static_cast<id>(this_swap.io_surface.get());
+      if ([layer_ contents] == new_contents)
+        [layer_ setContentsChanged];
+      else
+        [layer_ setContents:static_cast<id>(this_swap.io_surface.get())];

[Andre, 2015/08/05 17:59:30]

setContents:new_contents

[ccameron, 2015/08/06 18:55:18]

Done.

+      [layer_ setFrame:gfx::Rect(this_swap.dip_size).ToCGRect()];
+    }
   }
 
   // Remove this swap from the queue.
   pending_swaps_.pop_front();
 
   // Send acknowledgement to the browser.
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_handle =
       ui::SurfaceHandleFromCAContextID([ca_context_ contextId]);
   params.size = pixel_size_;
@@ skipping 98 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() {}
 
 
 ImageTransportSurfaceOverlayMac::PendingSwap::PendingSwap()
-    : fence(0) {
+    : fence(0), use_partial_damage(false) {
 }
 
 ImageTransportSurfaceOverlayMac::PendingSwap::~PendingSwap() {
 }
 
 }  // namespace content