Mac CoreAnimation compositor in the browser process

gpu/ipc/service/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 "gpu/ipc/service/image_transport_surface_overlay_mac.h"
 
 #include <CoreGraphics/CoreGraphics.h>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
@@ skipping 192 matching lines @@
     gl::ScopedSetGLToRealGLApi scoped_set_gl_api;
     TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFinish");
     CheckGLErrors("Before finish");
     glFinish();
     CheckGLErrors("After finish");
   }
 
   base::TimeTicks finish_time = base::TimeTicks::Now();
 
   bool fullscreen_low_power_layer_valid = false;
+/*
   ca_layer_tree_coordinator_->CommitPendingTreesToCA(
       pixel_damage_rect, &fullscreen_low_power_layer_valid);
+*/
   // TODO(ccameron): Plumb the fullscreen low power layer through to the
   // appropriate window.
 
   // Update the latency info to reflect the swap time.
   for (auto latency_info : latency_info_) {
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, finish_time, 1);
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
         finish_time, 1);
   }
 
   // Send acknowledgement to the browser.
   CAContextID ca_context_id = 0;
   CAContextID fullscreen_low_power_ca_context_id = 0;
   gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port;
+/*
   if (use_remote_layer_api_) {
     ca_context_id = [ca_context_ contextId];
     fullscreen_low_power_ca_context_id =
         [fullscreen_low_power_ca_context_ contextId];
   } else {
     IOSurfaceRef io_surface =
         ca_layer_tree_coordinator_->GetIOSurfaceForDisplay();
     if (io_surface)
       io_surface_mach_port.reset(IOSurfaceCreateMachPort(io_surface));
   }
+*/
   SendAcceleratedSurfaceBuffersSwapped(
       handle_, ca_context_id, fullscreen_low_power_layer_valid,
       fullscreen_low_power_ca_context_id, io_surface_mach_port, pixel_size_,
       scale_factor_, std::move(latency_info_));
 
   // Reset all state for the next frame.
   latency_info_.clear();
   return gfx::SwapResult::SWAP_ACK;
 }
 
@@ skipping 28 matching lines @@
     context->share_group()->SetRendererID(gl_renderer_id_);
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
     gl::GLImage* image,
     const gfx::Rect& pixel_frame_rect,
     const gfx::RectF& crop_rect) {
+  CHECK(0);
   if (transform != gfx::OVERLAY_TRANSFORM_NONE) {
     DLOG(ERROR) << "Invalid overlay plane transform.";
     return false;
   }
   if (z_order) {
     DLOG(ERROR) << "Invalid non-zero Z order.";
     return false;
   }
   return ca_layer_tree_coordinator_->SetPendingGLRendererBackbuffer(
       static_cast<gl::GLImageIOSurface*>(image)->io_surface());
 }
 
 bool ImageTransportSurfaceOverlayMac::ScheduleCALayer(
     gl::GLImage* contents_image,
     const gfx::RectF& contents_rect,
     float opacity,
     unsigned background_color,
     unsigned edge_aa_mask,
     const gfx::RectF& rect,
     bool is_clipped,
     const gfx::RectF& clip_rect,
     const gfx::Transform& transform,
     int sorting_context_id,
     unsigned filter) {
+  CHECK(0);
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
   base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
   if (contents_image) {
     gl::GLImageIOSurface* io_surface_image =
         static_cast<gl::GLImageIOSurface*>(contents_image);
     io_surface = io_surface_image->io_surface();
     cv_pixel_buffer = io_surface_image->cv_pixel_buffer();
   }
   return ca_layer_tree_coordinator_->GetPendingCARendererLayerTree()
       ->ScheduleCALayer(is_clipped, gfx::ToEnclosingRect(clip_rect),
@@ skipping 32 matching lines @@
   gl_renderer_id_ = context_renderer_id & kCGLRendererIDMatchingMask;
 
   // Post a task holding a reference to the new GL context. The reason for
   // this is to avoid creating-then-destroying the context for every image
   // transport surface that is observing the GPU switch.
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&IOSurfaceContextNoOp, context_on_new_gpu));
 }
 
 }  // namespace gpu