Mac fullscreen low power: Plumb through to AcceleratedWidgetMac

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 89 matching lines @@
       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_context_ setLayer:ca_layer_tree_coordinator_->GetCALayerForDisplay()];
+
+    fullscreen_low_power_ca_context_.reset([
+        [CAContext contextWithCGSConnection:connection_id options:@{}] retain]);
+    [fullscreen_low_power_ca_context_ setLayer:
+        ca_layer_tree_coordinator_->GetFullscreenLowPowerLayerForDisplay()];
   }
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::Destroy() {
   ca_layer_tree_coordinator_.reset();
 }
 
 bool ImageTransportSurfaceOverlayMac::IsOffscreen() {
   return false;
@@ skipping 17 matching lines @@
   if (vsync_parameters_valid_) {
     vsync_timebase_ -=
         vsync_interval_ *
         ((vsync_timebase_ - base::TimeTicks()) / vsync_interval_);
   }
 }
 
 void ImageTransportSurfaceOverlayMac::SendAcceleratedSurfaceBuffersSwapped(
     gpu::SurfaceHandle surface_handle,
     CAContextID ca_context_id,
+    bool fullscreen_low_power_ca_context_valid,
+    CAContextID fullscreen_low_power_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());
   manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(
-      surface_handle, ca_context_id, io_surface, size, scale_factor,
+      surface_handle, ca_context_id, fullscreen_low_power_ca_context_valid,
+      fullscreen_low_power_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");
 
   // A glFlush is necessary to ensure correct content appears. A glFinish
   // appears empirically to be the best way to get maximum performance when
   // GPU bound.
@@ skipping 17 matching lines @@
   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,
-                                       io_surface_mach_port, pixel_size_,
-                                       scale_factor_, std::move(latency_info_));
+  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;
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffers() {
   return SwapBuffersInternal(
       gfx::Rect(0, 0, pixel_size_.width(), pixel_size_.height()));
 }
@@ skipping 100 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