Move logic from ImageTransportSurfaceOverlayMac into ui/

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>
 #include <OpenGL/gl.h>
 #include <stddef.h>
 
 #include <algorithm>
 
 // This type consistently causes problem on Mac, and needs to be dealt with
 // in a systemic way.
 // http://crbug.com/517208
 #ifndef GL_OES_EGL_image
 typedef void* GLeglImageOES;
 #endif
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
-#include "ui/accelerated_widget_mac/ca_layer_partial_damage_tree_mac.h"
-#include "ui/accelerated_widget_mac/ca_layer_tree_mac.h"
+#include "ui/accelerated_widget_mac/ca_layer_tree_coordinator.h"
 #include "ui/accelerated_widget_mac/io_surface_context.h"
 #include "ui/base/cocoa/animation_utils.h"
 #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"
@@ skipping 30 matching lines @@
       stub_(stub->AsWeakPtr()),
       handle_(handle),
       use_remote_layer_api_(ui::RemoteLayerAPISupported()),
       scale_factor_(1),
       gl_renderer_id_(0),
       vsync_parameters_valid_(false) {
   manager_->AddBufferPresentedCallback(
       handle_, base::Bind(&ImageTransportSurfaceOverlayMac::BufferPresented,
                           base::Unretained(this)));
   ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
+  ca_layer_tree_coordinator_.reset(
+      new ui::CALayerTreeCoordinator(use_remote_layer_api_));
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
   ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
   Destroy();
   manager_->RemoveBufferPresentedCallback(handle_);
 }
 
 bool ImageTransportSurfaceOverlayMac::Initialize(
     gfx::GLSurface::Format format) {
   if (!stub_.get() || !stub_->decoder())
     return false;
 
   stub_->SetLatencyInfoCallback(
       base::Bind(&ImageTransportSurfaceOverlayMac::SetLatencyInfo,
                  base::Unretained(this)));
 
   // 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_];
+    [ca_context_ setLayer:ca_layer_tree_coordinator_->GetCALayerForDisplay()];
   }
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
-  current_partial_damage_tree_.reset();
-  current_ca_layer_tree_.reset();
+  ca_layer_tree_coordinator_.reset();
 }
 
 bool ImageTransportSurfaceOverlayMac::IsOffscreen() {
   return false;
 }
 
 void ImageTransportSurfaceOverlayMac::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   latency_info_.insert(latency_info_.end(), latency_info.begin(),
                        latency_info.end());
@@ skipping 43 matching lines @@
   {
     gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
     TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFinish");
     CheckGLErrors("Before finish");
     glFinish();
     CheckGLErrors("After finish");
   }
 
   base::TimeTicks finish_time = base::TimeTicks::Now();
 
-  // Update the CALayer hierarchy.
-  {
-    ScopedCAActionDisabler disabler;
-    if (pending_ca_layer_tree_) {
-      pending_ca_layer_tree_->CommitScheduledCALayers(
-          ca_root_layer_.get(), std::move(current_ca_layer_tree_),
-          scale_factor_);
-      current_ca_layer_tree_.swap(pending_ca_layer_tree_);
-      current_partial_damage_tree_.reset();
-    } else if (pending_partial_damage_tree_) {
-      pending_partial_damage_tree_->CommitCALayers(
-          ca_root_layer_.get(), std::move(current_partial_damage_tree_),
-          scale_factor_, pixel_damage_rect);
-      current_partial_damage_tree_.swap(pending_partial_damage_tree_);
-      current_ca_layer_tree_.reset();
-    } else {
-      TRACE_EVENT0("gpu", "Blank frame: No overlays or CALayers");
-      [ca_root_layer_ setSublayers:nil];
-      current_partial_damage_tree_.reset();
-      current_ca_layer_tree_.reset();
-    }
-  }
+  ca_layer_tree_coordinator_->CommitPendingTreesToCA(pixel_damage_rect);
 
   // 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;
-  gfx::ScopedRefCountedIOSurfaceMachPort io_surface;
+  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port;
   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()));
+  } 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, io_surface,
-                                       pixel_size_, scale_factor_,
-                                       std::move(latency_info_));
+  SendAcceleratedSurfaceBuffersSwapped(handle_, 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();
-  pending_ca_layer_tree_.reset();
-  pending_partial_damage_tree_.reset();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffers() {
   return SwapBuffersInternal(
       gfx::Rect(0, 0, pixel_size_.width(), pixel_size_.height()));
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::PostSubBuffer(int x,
                                                                int y,
@@ skipping 29 matching lines @@
     const gfx::Rect& pixel_frame_rect,
     const gfx::RectF& crop_rect) {
   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;
   }
-  if (pending_partial_damage_tree_) {
-    DLOG(ERROR) << "Only one overlay per swap is allowed.";
-    return false;
-  }
-  pending_partial_damage_tree_.reset(new ui::CALayerPartialDamageTree(
-      use_remote_layer_api_,
-      static_cast<gl::GLImageIOSurface*>(image)->io_surface(),
-      pixel_frame_rect));
-  return true;
+  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) {
   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();
   }
-  if (!pending_ca_layer_tree_)
-    pending_ca_layer_tree_.reset(new ui::CALayerTree);
-  return pending_ca_layer_tree_->ScheduleCALayer(
-      is_clipped, gfx::ToEnclosingRect(clip_rect), sorting_context_id,
-      transform, io_surface, cv_pixel_buffer, contents_rect,
-      gfx::ToEnclosingRect(rect), background_color, edge_aa_mask, opacity);
+  return ca_layer_tree_coordinator_->GetPendingCARendererLayerTree()
+      ->ScheduleCALayer(
+          is_clipped, gfx::ToEnclosingRect(clip_rect), sorting_context_id,
+          transform, io_surface, cv_pixel_buffer, contents_rect,
+          gfx::ToEnclosingRect(rect), background_color, edge_aa_mask, opacity);
 }
 
 bool ImageTransportSurfaceOverlayMac::IsSurfaceless() const {
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::Resize(const gfx::Size& pixel_size,
                                              float scale_factor,
                                              bool has_alpha) {
-  // Flush through any pending frames.
   pixel_size_ = pixel_size;
   scale_factor_ = scale_factor;
+  ca_layer_tree_coordinator_->Resize(pixel_size, scale_factor);
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::OnGpuSwitched() {
   // Create a new context, and use the GL renderer ID that the new context gets.
   scoped_refptr<ui::IOSurfaceContext> context_on_new_gpu =
       ui::IOSurfaceContext::Get(ui::IOSurfaceContext::kCALayerContext);
   if (!context_on_new_gpu)
     return;
   GLint context_renderer_id = -1;
   if (CGLGetParameter(context_on_new_gpu->cgl_context(),
                       kCGLCPCurrentRendererID,
                       &context_renderer_id) != kCGLNoError) {
     LOG(ERROR) << "Failed to create test context after GPU switch";
     return;
   }
   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