Add detached mode plumbing

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 <AVFoundation/AVFoundation.h>
 #include <CoreGraphics/CoreGraphics.h>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
 
 #include <algorithm>
 
 // This type consistently causes problem on Mac, and needs to be dealt with
@@ skipping 16 matching lines @@
 #include "ui/base/cocoa/remote_layer_api.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image_io_surface.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_cgl.h"
 
+#if !defined(MAC_OS_X_VERSION_10_8) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8
+extern NSString* const AVLayerVideoGravityResize;
+#endif  // MAC_OS_X_VERSION_10_8
+
 namespace {
 
 // Don't let a frame draw until 5% of the way through the next vsync interval
 // after the call to SwapBuffers. This slight offset is to ensure that skew
 // doesn't result in the frame being presented to the previous vsync interval.
 const double kVSyncIntervalFractionForEarliestDisplay = 0.05;
 
 // After doing a glFlush and putting in a fence in SwapBuffers, post a task to
 // query the fence 50% of the way through the next vsync interval. If we are
 // trying to animate smoothly, then want to query the fence at the next
@@ skipping 19 matching lines @@
 }
 
 }  // namespace
 
 @interface CALayer(Private)
 -(void)setContentsChanged;
 @end
 
 namespace content {
 
+void UpdateVideoLayer(AVSampleBufferDisplayLayer* sample_buffer_display_layer);
+
 scoped_refptr<gfx::GLSurface> ImageTransportSurfaceCreateNativeSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gpu::SurfaceHandle handle) {
   return new ImageTransportSurfaceOverlayMac(manager, stub, handle);
 }
 
 class ImageTransportSurfaceOverlayMac::PendingSwap {
  public:
   PendingSwap() {}
@@ skipping 62 matching lines @@
   // Create the CAContext to send this to the GPU process, and the layer for
   // the context.
   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_];
+
+    detached_ca_context_.reset([
+        [CAContext contextWithCGSConnection:connection_id options:@{}] retain]);
+    detached_av_layer_.reset([[AVSampleBufferDisplayLayer alloc] init]);
+    [detached_av_layer_ setVideoGravity:AVLayerVideoGravityResize];
+    [detached_ca_context_ setLayer:detached_av_layer_];
+    [detached_av_layer_ setFrame:CGRectMake(0, 0, 1280, 720)];
   }
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
   DisplayAndClearAllPendingSwaps();
 
   current_partial_damage_tree_.reset();
   current_ca_layer_tree_.reset();
 }
@@ skipping 17 matching lines @@
   vsync_parameters_valid_ = (vsync_interval_ != base::TimeDelta());
 
   // Compute |vsync_timebase_| to be the first vsync after time zero.
   if (vsync_parameters_valid_) {
     vsync_timebase_ -=
         vsync_interval_ *
         ((vsync_timebase_ - base::TimeTicks()) / vsync_interval_);
   }
 }
 
-void ImageTransportSurfaceOverlayMac::SendAcceleratedSurfaceBuffersSwapped(
-    int32_t surface_id,
-    CAContextID ca_context_id,
-    const gfx::ScopedRefCountedIOSurfaceMachPort& io_surface,
-    const gfx::Size& size,
-    float scale_factor,
-    std::vector<ui::LatencyInfo> latency_info) {
-  // TRACE_EVENT for gpu tests:
-  TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffers", TRACE_EVENT_SCOPE_THREAD,
-                       "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
-                       "width", size.width());
-  // On mac, handle_ is a surface id. See
-  // GpuProcessTransportFactory::CreatePerCompositorData
-  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(
-      surface_id, ca_context_id, io_surface, size, scale_factor,
-      std::move(latency_info));
-}
-
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffersInternal(
     const gfx::Rect& pixel_damage_rect) {
   TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::SwapBuffersInternal");
 
   // Use the same concept of 'now' for the entire function. The duration of
   // this function only affect the result if this function lasts across a vsync
   // boundary, in which case smooth animation is out the window anyway.
   const base::TimeTicks now = base::TimeTicks::Now();
 
   // Decide if the frame should be drawn immediately, or if we should wait until
@@ skipping 94 matching lines @@
   if (swap->gl_fence) {
     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 CALayer hierarchy.
+  bool use_detached_mode = false;
   {
     gfx::RectF pixel_damage_rect = gfx::RectF(swap->pixel_damage_rect);
     ScopedCAActionDisabler disabler;
     if (swap->ca_layer_tree) {
       swap->ca_layer_tree->CommitScheduledCALayers(
-          ca_root_layer_.get(), std::move(current_ca_layer_tree_),
-          swap->scale_factor);
+          ca_root_layer_.get(), &use_detached_mode, detached_av_layer_.get(),
+          std::move(current_ca_layer_tree_), swap->scale_factor);
       current_ca_layer_tree_.swap(swap->ca_layer_tree);
       current_partial_damage_tree_.reset();
     } else if (swap->partial_damage_tree) {
       swap->partial_damage_tree->CommitCALayers(
           ca_root_layer_.get(), std::move(current_partial_damage_tree_),
           swap->scale_factor, swap->pixel_damage_rect);
       current_partial_damage_tree_.swap(swap->partial_damage_tree);
       current_ca_layer_tree_.reset();
     } else {
       TRACE_EVENT0("gpu", "Blank frame: No overlays or CALayers");
@@ skipping 21 matching lines @@
   if (use_remote_layer_api_) {
     ca_context_id = [ca_context_ contextId];
   } else if (current_partial_damage_tree_) {
     io_surface.reset(IOSurfaceCreateMachPort(
         current_partial_damage_tree_->RootLayerIOSurface()));
   }
   gfx::Size size = swap->pixel_size;
   float scale_factor = swap->scale_factor;
   std::vector<ui::LatencyInfo> latency_info;
   latency_info.swap(swap->latency_info);
-  SendAcceleratedSurfaceBuffersSwapped(handle_, ca_context_id, io_surface, size,
-                                       scale_factor, std::move(latency_info));
+
+  CAContextID detached_ca_context_id = [detached_ca_context_ contextId];
+
+  // TRACE_EVENT for gpu tests:
+  TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffers", TRACE_EVENT_SCOPE_THREAD,
+                       "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
+                       "width", size.width());
+  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(
+      handle_, ca_context_id, io_surface, use_detached_mode, detached_ca_context_id,
+      size, scale_factor, std::move(latency_info));
 
   // Remove this from the queue, and reset any callback timers.
   pending_swaps_.pop_front();
 }
 
 void ImageTransportSurfaceOverlayMac::DisplayAndClearAllPendingSwaps() {
   TRACE_EVENT0("gpu",
       "ImageTransportSurfaceOverlayMac::DisplayAndClearAllPendingSwaps");
   while (!pending_swaps_.empty())
     DisplayFirstPendingSwapImmediately();
@@ skipping 161 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