Mac Overlays: Allow the primary plane to be optionally scheduled.

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 <algorithm>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
@@ skipping 70 matching lines @@
 }  // namespace
 
 @interface CALayer(Private)
 -(void)setContentsChanged;
 @end
 
 namespace content {
 
 class ImageTransportSurfaceOverlayMac::OverlayPlane {
  public:
-  enum Type {
-    ROOT = 0,
-    ROOT_PARTIAL_DAMAGE = 1,
-    OVERLAY = 2,
-  };
-
-  OverlayPlane(Type type,
-               int z_order,
+  OverlayPlane(int z_order,
                base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                const gfx::RectF& dip_frame_rect,
                const gfx::RectF& contents_rect)
-      : type(type),
-        z_order(z_order),
+      : z_order(z_order),
         io_surface(io_surface),
         dip_frame_rect(dip_frame_rect),
         contents_rect(contents_rect),
         layer_needs_update(true) {}
   ~OverlayPlane() { DCHECK(!ca_layer); }
 
-  const Type type;
   const int z_order;
   base::scoped_nsobject<CALayer> ca_layer;
 
   // The IOSurface to set the CALayer's contents to.
   const base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
   const gfx::RectF dip_frame_rect;
   const gfx::RectF contents_rect;
 
   bool layer_needs_update;
 
   static bool Compare(const linked_ptr<OverlayPlane>& a,
                       const linked_ptr<OverlayPlane>& b) {
-    // Sort by z_order first.
-    if (a->z_order < b->z_order)
-      return true;
-    if (a->z_order > b->z_order)
-      return false;
-    // Then ensure that the root partial damage is after the root.
-    if (a->type < b->type)
-      return true;
-    if (a->type > b->type)
-      return false;
-    // Then sort by x.
-    if (a->dip_frame_rect.x() < b->dip_frame_rect.x())
-      return true;
-    if (a->dip_frame_rect.x() > b->dip_frame_rect.x())
-      return false;
-    // Then sort by y.
-    if (a->dip_frame_rect.y() < b->dip_frame_rect.y())
-      return true;
-    if (a->dip_frame_rect.y() > b->dip_frame_rect.y())
-      return false;
-
-    return false;
+    return (a->z_order < b->z_order);
   }
 
   void TakeCALayerFrom(OverlayPlane* other_plane) {
     ca_layer.swap(other_plane->ca_layer);
   }
 
   void UpdateProperties() {
     if (layer_needs_update) {
       [ca_layer setOpaque:YES];
       [ca_layer setFrame:dip_frame_rect.ToCGRect()];
       [ca_layer setContentsRect:contents_rect.ToCGRect()];
       id new_contents = static_cast<id>(io_surface.get());
-      if ([ca_layer contents] == new_contents && type != OVERLAY) {
+      if ([ca_layer contents] == new_contents && z_order == 0) {
         [ca_layer setContentsChanged];
       } else {
         [ca_layer setContents:new_contents];
       }
     }
     static bool show_borders =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kShowMacOverlayBorders);
     if (show_borders) {
       base::ScopedCFTypeRef<CGColorRef> color;
       if (!layer_needs_update) {
         // Green represents contents that are unchanged across frames.
         color.reset(CGColorCreateGenericRGB(0, 1, 0, 1));
-      } else if (type == OverlayPlane::OVERLAY) {
+      } else if (z_order != 0) {
         // Pink represents overlay planes
         color.reset(CGColorCreateGenericRGB(1, 0, 1, 1));
       } else {
         // Red represents damaged contents.
         color.reset(CGColorCreateGenericRGB(1, 0, 0, 1));
       }
       [ca_layer setBorderWidth:2];
       [ca_layer setBorderColor:color];
     }
     layer_needs_update = false;
   }
 
   void Destroy() {
     if (!ca_layer)
       return;
     [ca_layer setContents:nil];
-    if (type != ROOT)
-      [ca_layer removeFromSuperlayer];
+    [ca_layer removeFromSuperlayer];

[ccameron, 2015/10/05 20:44:42]

I was vaguely concerned about this having odd interactions with CAContext, but
if this works, sounds good to me.

[Andre, 2015/10/05 20:53:13]

We could check if ([ca_layer superlayer]), but removeFromSuperlayer should do
the same check.

     ca_layer.reset();
   }
 };
 
 class ImageTransportSurfaceOverlayMac::PendingSwap {
  public:
   PendingSwap() {}
   ~PendingSwap() { DCHECK(!gl_fence); }
 
   gfx::Size pixel_size;
   float scale_factor;
   gfx::Rect pixel_damage_rect;
 
+  linked_ptr<OverlayPlane> root_plane;
   std::vector<linked_ptr<OverlayPlane>> overlay_planes;
   std::vector<ui::LatencyInfo> latency_info;
 
   // 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 79 matching lines @@
     if (IsFirstPendingSwapReadyToDisplay(now))
       DisplayFirstPendingSwapImmediately();
   }
 
   // The remainder of the function will populate the PendingSwap structure and
   // then enqueue it.
   linked_ptr<PendingSwap> new_swap(new PendingSwap);
   new_swap->pixel_size = pixel_size_;
   new_swap->scale_factor = scale_factor_;
   new_swap->pixel_damage_rect = pixel_damage_rect;
+  new_swap->root_plane = pending_root_plane_;
+  pending_root_plane_ = linked_ptr<OverlayPlane>();
   new_swap->overlay_planes.swap(pending_overlay_planes_);
   new_swap->latency_info.swap(latency_info_);
 
   // A flush is required to ensure that all content appears in the layer.
   {
     gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
     TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFlush");
     CheckGLErrors("before flushing frame");
     new_swap->cgl_context.reset(CGLGetCurrentContext(),
                                 base::scoped_policy::RETAIN);
@@ skipping 61 matching lines @@
     gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
     gfx::ScopedCGLSetCurrentContext scoped_set_current(swap->cgl_context);
 
     CheckGLErrors("before deleting active fence");
     swap->gl_fence.reset();
     CheckGLErrors("while deleting active fence");
   }
 
   // Update the plane lists.
   {
-    // Sort the input planes by z-index and type, and remove any overlays from
-    // the damage rect.
+    // Sort the input planes by z-index, and remove any overlays from the
+    // damage rect.
     gfx::RectF dip_damage_rect = ConvertRectToDIPF(
         swap->scale_factor, swap->pixel_damage_rect);
     std::sort(swap->overlay_planes.begin(), swap->overlay_planes.end(),
               OverlayPlane::Compare);
-    for (auto& plane : swap->overlay_planes) {
-      if (plane->type == OverlayPlane::OVERLAY)
-        dip_damage_rect.Subtract(plane->dip_frame_rect);
-    }
+    for (auto& plane : swap->overlay_planes)
+      dip_damage_rect.Subtract(plane->dip_frame_rect);
 
     ScopedCAActionDisabler disabler;
-    UpdateRootAndPartialDamagePlanes(swap->overlay_planes, dip_damage_rect);
+    if (swap->root_plane.get())
+      UpdateRootAndPartialDamagePlanes(swap->root_plane, dip_damage_rect);
     UpdateOverlayPlanes(swap->overlay_planes);
     UpdateCALayerTree();
     swap->overlay_planes.clear();
   }
 
   // Send acknowledgement to the browser.
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_handle =
       ui::SurfaceHandleFromCAContextID([ca_context_ contextId]);
   params.size = swap->pixel_size;
   params.scale_factor = swap->scale_factor;
   params.latency_info.swap(swap->latency_info);
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
   // Remove this from the queue, and reset any callback timers.
   pending_swaps_.pop_front();
 }
 
 void ImageTransportSurfaceOverlayMac::UpdateOverlayPlanes(
     const std::vector<linked_ptr<OverlayPlane>>& new_overlay_planes) {
   std::list<linked_ptr<OverlayPlane>> old_overlay_planes;
   old_overlay_planes.swap(current_overlay_planes_);
 
   // Move the new overlay planes into the |current_overlay_planes_| list,
   // cannibalizing from the old |current_overlay_planes_| as much as possible.
   for (auto& new_plane : new_overlay_planes) {
-    if (new_plane->type == OverlayPlane::OVERLAY) {
-      if (!old_overlay_planes.empty()) {
-        new_plane->TakeCALayerFrom(old_overlay_planes.front().get());
-        old_overlay_planes.pop_front();
-      }
-      current_overlay_planes_.push_back(new_plane);
+    if (!old_overlay_planes.empty()) {
+      new_plane->TakeCALayerFrom(old_overlay_planes.front().get());
+      old_overlay_planes.pop_front();
     }
+    current_overlay_planes_.push_back(new_plane);
   }
 
   // Destroy any of the previous |current_overlay_planes_| that we couldn't
   // cannibalize.
   for (auto& old_plane : old_overlay_planes)
     old_plane->Destroy();
 }
 
 void ImageTransportSurfaceOverlayMac::UpdateRootAndPartialDamagePlanes(
-    const std::vector<linked_ptr<OverlayPlane>>& new_overlay_planes,
+    const linked_ptr<OverlayPlane>& new_root_plane,
     const gfx::RectF& dip_damage_rect) {
   std::list<linked_ptr<OverlayPlane>> old_partial_damage_planes;
   old_partial_damage_planes.swap(current_partial_damage_planes_);
-  linked_ptr<OverlayPlane> new_root_plane = new_overlay_planes.front();
   linked_ptr<OverlayPlane> plane_for_swap;
 
   // If the frame's size changed, if we haven't updated the root layer, or if
   // we have full damage, then use the root layer directly.
   if (!current_root_plane_.get() ||
       current_root_plane_->dip_frame_rect != new_root_plane->dip_frame_rect ||
       dip_damage_rect == new_root_plane->dip_frame_rect) {
     plane_for_swap = new_root_plane;
   }
 
@@ skipping 21 matching lines @@
       plane_to_reuse_dip_enlarged_rect.Union(dip_enlarged_rect);
     }
 
     if (plane_to_reuse.get()) {
       gfx::RectF enlarged_contents_rect = plane_to_reuse_dip_enlarged_rect;
       enlarged_contents_rect.Scale(
           1. / new_root_plane->dip_frame_rect.width(),
           1. / new_root_plane->dip_frame_rect.height());
 
       plane_for_swap = linked_ptr<OverlayPlane>(new OverlayPlane(
-          OverlayPlane::ROOT_PARTIAL_DAMAGE, 0, new_root_plane->io_surface,
-          plane_to_reuse_dip_enlarged_rect, enlarged_contents_rect));
+          0, new_root_plane->io_surface, plane_to_reuse_dip_enlarged_rect,
+          enlarged_contents_rect));
 
       plane_for_swap->TakeCALayerFrom(plane_to_reuse.get());
       if (plane_to_reuse != old_partial_damage_planes.back())
         [plane_for_swap->ca_layer removeFromSuperlayer];
     }
   }
 
   // If we haven't found an appropriate layer to re-use, create a new one, if
   // we haven't already created too many.
   if (!plane_for_swap.get() && !dip_damage_rect.IsEmpty() &&
       old_partial_damage_planes.size() < kMaximumPartialDamageLayers) {
     gfx::RectF contents_rect = gfx::RectF(dip_damage_rect);
     contents_rect.Scale(1. / new_root_plane->dip_frame_rect.width(),
                         1. / new_root_plane->dip_frame_rect.height());
     plane_for_swap = linked_ptr<OverlayPlane>(new OverlayPlane(
-        OverlayPlane::ROOT_PARTIAL_DAMAGE, 0, new_root_plane->io_surface,
-        dip_damage_rect, contents_rect));
+        0, new_root_plane->io_surface, dip_damage_rect, contents_rect));
   }
 
   // And if we still don't have a layer, use the root layer.
   if (!plane_for_swap.get() && !dip_damage_rect.IsEmpty())
     plane_for_swap = new_root_plane;
 
   // Walk all old partial damage planes. Remove anything that is now completely
   // covered, and move everything else into the new
   // |current_partial_damage_planes_|.
   for (auto& old_plane : old_partial_damage_planes) {
@@ skipping 47 matching lines @@
       if (first_overlay_ca_layer) {
         [ca_root_layer_ insertSublayer:plane->ca_layer
                                  below:first_overlay_ca_layer];
       } else {
         [ca_root_layer_ addSublayer:plane->ca_layer];
       }
     }
   }
 
   // Update CALayer contents, frames, and borders.
-  current_root_plane_->UpdateProperties();
+  if (current_root_plane_.get())
+    current_root_plane_->UpdateProperties();
   for (auto& plane : current_partial_damage_planes_)
     plane->UpdateProperties();
   for (auto& plane : current_overlay_planes_)
     plane->UpdateProperties();
 
   DCHECK_EQ(
       static_cast<size_t>([[ca_root_layer_ sublayers] count]),
       current_partial_damage_planes_.size() + current_overlay_planes_.size());
 }
 
@@ skipping 72 matching lines @@
   }
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
     gfx::GLImage* image,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
-  DCHECK_GE(z_order, 0);
   DCHECK_EQ(transform, gfx::OVERLAY_TRANSFORM_NONE);
-  if (z_order < 0 || transform != gfx::OVERLAY_TRANSFORM_NONE)
+  if (transform != gfx::OVERLAY_TRANSFORM_NONE)
     return false;
 
-  OverlayPlane::Type type = z_order == 0 ?
-      OverlayPlane::ROOT : OverlayPlane::OVERLAY;
   gfx::RectF dip_frame_rect = ConvertRectToDIPF(
       scale_factor_, bounds_rect);
-  gfx::RectF contents_rect = crop_rect;
 
-  gfx::GLImageIOSurface* image_io_surface =
-      static_cast<gfx::GLImageIOSurface*>(image);
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
+  if (image)

[ccameron, 2015/10/05 20:44:42]

Do we need this -- is image ever nullptr?

[Andre, 2015/10/05 20:53:13]

This was leftover from scheduling SolidColor tiles through here, it's never
nullptr otherwise.
Fixed in patchset 2.

+    io_surface = static_cast<gfx::GLImageIOSurface*>(image)->io_surface();
 
-  pending_overlay_planes_.push_back(linked_ptr<OverlayPlane>(
-      new OverlayPlane(
-          type, z_order, image_io_surface->io_surface(), dip_frame_rect,
-          contents_rect)));
+  linked_ptr<OverlayPlane> plane(
+      new OverlayPlane(z_order, io_surface, dip_frame_rect, crop_rect));
+  if (z_order == 0)
+    pending_root_plane_ = plane;
+  else
+    pending_overlay_planes_.push_back(plane);
+
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::IsSurfaceless() const {
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   vsync_timebase_ = params.vsync_timebase;
@@ skipping 52 matching lines @@
   // Compute the previous vsync time.
   base::TimeTicks previous_vsync =
       vsync_interval_ * ((from - vsync_timebase_) / vsync_interval_) +
       vsync_timebase_;
 
   // Return |interval_fraction| through the next vsync.
   return previous_vsync + (1 + interval_fraction) * vsync_interval_;
 }
 
 }  // namespace content