Mac: Always use surfaceless mode

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 68 matching lines @@
 }
 
 }  // namespace
 
 @interface CALayer(Private)
 -(void)setContentsChanged;
 @end
 
 namespace content {
 
+scoped_refptr<gfx::GLSurface> ImageTransportSurfaceCreateNativeSurface(
+    GpuChannelManager* manager,
+    GpuCommandBufferStub* stub,
+    gfx::PluginWindowHandle handle) {
+  return new ImageTransportSurfaceOverlayMac(manager, stub, handle);
+}
+
 class ImageTransportSurfaceOverlayMac::OverlayPlane {
  public:
   OverlayPlane(int z_order,
+               int io_surface_id,
                base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                const gfx::RectF& dip_frame_rect,
                const gfx::RectF& contents_rect)
       : z_order(z_order),
+        io_surface_id(io_surface_id),
         io_surface(io_surface),
         dip_frame_rect(dip_frame_rect),
         contents_rect(contents_rect),
         layer_needs_update(true) {}
   ~OverlayPlane() { DCHECK(!ca_layer); }
 
   const int z_order;
   base::scoped_nsobject<CALayer> ca_layer;
 
   // The IOSurface to set the CALayer's contents to.
+  const int io_surface_id;
   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) {
     return (a->z_order < b->z_order);
   }
@@ skipping 68 matching lines @@
 
   // The time that this will wake up and draw, if a following swap does not
   // cause it to draw earlier.
   base::TimeTicks target_display_time;
 };
 
 ImageTransportSurfaceOverlayMac::ImageTransportSurfaceOverlayMac(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::PluginWindowHandle handle)
-    : scale_factor_(1), gl_renderer_id_(0), vsync_parameters_valid_(false),
-      display_pending_swap_timer_(true, false), weak_factory_(this) {
+    : use_remote_layer_api_(ui::RemoteLayerAPISupported()),
+      scale_factor_(1),
+      gl_renderer_id_(0),
+      vsync_parameters_valid_(false),
+      display_pending_swap_timer_(true, false),
+      weak_factory_(this) {
   helper_.reset(new ImageTransportHelper(this, manager, stub, handle));
   ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
   ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
   Destroy();
 }
 
 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]);
-  ca_root_layer_.reset([[CALayer alloc] init]);
-  [ca_root_layer_ setGeometryFlipped:YES];
-  [ca_root_layer_ setOpaque:YES];
-  [ca_context_ setLayer:ca_root_layer_];
+  if (use_remote_layer_api_) {
+    CGSConnectionID connection_id = CGSMainConnectionID();
+    ca_context_.reset([
+        [CAContext contextWithCGSConnection:connection_id options:@{}] retain]);
+    ca_root_layer_.reset([[CALayer alloc] init]);
+    [ca_root_layer_ setGeometryFlipped:YES];
+    [ca_root_layer_ setOpaque:YES];
+    [ca_context_ setLayer:ca_root_layer_];
+  }
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
   DisplayAndClearAllPendingSwaps();
 
   if (current_root_plane_.get())
     current_root_plane_->Destroy();
   current_root_plane_.reset();
   for (auto& plane : current_partial_damage_planes_)
@@ skipping 135 matching lines @@
 
     ScopedCAActionDisabler disabler;
     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]);
+  if (use_remote_layer_api_) {
+    params.surface_handle =
+        ui::SurfaceHandleFromCAContextID([ca_context_ contextId]);
+  } else {
+    params.surface_handle =
+        ui::SurfaceHandleFromIOSurfaceID(current_root_plane_->io_surface_id);
+  }
   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(
@@ skipping 27 matching lines @@
   // If there is no new root plane, destroy the old one.
   if (!new_root_plane.get()) {
     for (auto& old_plane : old_partial_damage_planes)
       old_plane->Destroy();
     if (current_root_plane_.get())
       current_root_plane_->Destroy();
     current_root_plane_.reset();
     return;
   }
 
-  // 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() ||
+  // If the frame's size changed, if we haven't updated the root layer, if
+  // we have full damage, or if we don't support remote layers, then use the
+  // root layer directly.
+  if (!use_remote_layer_api_ || !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;
   }
 
   // Walk though the existing partial damage layers and see if there is one that
   // is appropriate to re-use.
   if (!plane_for_swap.get() && !dip_damage_rect.IsEmpty()) {
     gfx::RectF plane_to_reuse_dip_enlarged_rect;
 
@@ skipping 16 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(
-          0, new_root_plane->io_surface, plane_to_reuse_dip_enlarged_rect,
-          enlarged_contents_rect));
+          0, new_root_plane->io_surface_id, 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(
-        0, new_root_plane->io_surface, dip_damage_rect, contents_rect));
+        0, new_root_plane->io_surface_id, 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 18 matching lines @@
     } else {
       plane_for_swap->ca_layer = ca_root_layer_;
     }
     current_root_plane_ = new_root_plane;
   } else if (plane_for_swap.get()) {
     current_partial_damage_planes_.push_back(plane_for_swap);
   }
 }
 
 void ImageTransportSurfaceOverlayMac::UpdateCALayerTree() {
+  if (!use_remote_layer_api_) {
+    DCHECK(current_overlay_planes_.empty());
+    DCHECK(current_partial_damage_planes_.empty());
+    return;
+  }
+
   // Allocate new CALayers as needed. Overlay layers are always added to the
   // back of the list.
   CALayer* first_overlay_ca_layer = nil;
   for (auto& plane : current_overlay_planes_) {
     if (!plane->ca_layer) {
       plane->ca_layer.reset([[CALayer alloc] init]);
       [ca_root_layer_ addSublayer:plane->ca_layer];
     }
     if (!first_overlay_ca_layer)
       first_overlay_ca_layer = plane->ca_layer;
@@ skipping 97 matching lines @@
 }
 
 bool ImageTransportSurfaceOverlayMac::SetBackbufferAllocation(bool allocated) {
   if (!allocated) {
     DisplayAndClearAllPendingSwaps();
     last_swap_time_ = base::TimeTicks();
   }
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(

[reveman, 2015/10/23 20:44:40]

Can you remind me what the call stack for this function typically looks like? Is
this going through GLImageIOSurface before this is called? Not need to change
anything in this patch, I just like to be sure that I understand why the static
cast below is safe..

[ccameron, 2015/10/26 22:28:11]

I think that this needs to be made safer as well -- it appears that it's only
safe by the coincidence that we only we only schedule overlays for
GLImageIOSurfaces on Mac (which we could easily screw up in the future).

I'll spin up a new patch to clean this up.

     int z_order,
     gfx::OverlayTransform transform,
     gfx::GLImage* image,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
   DCHECK_EQ(transform, gfx::OVERLAY_TRANSFORM_NONE);
   if (transform != gfx::OVERLAY_TRANSFORM_NONE)
     return false;
 
-  linked_ptr<OverlayPlane> plane(
-      new OverlayPlane(z_order,
-                       static_cast<gfx::GLImageIOSurface*>(image)->io_surface(),
-                       ConvertRectToDIPF(scale_factor_, bounds_rect),
-                       crop_rect));
+  linked_ptr<OverlayPlane> plane(new OverlayPlane(
+      z_order, static_cast<gfx::GLImageIOSurface*>(image)->io_surface_id().id,
+      static_cast<gfx::GLImageIOSurface*>(image)->io_surface(),
+      ConvertRectToDIPF(scale_factor_, bounds_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;
@@ skipping 57 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