Mac: Always use surfaceless mode

ui/accelerated_widget_mac/accelerated_widget_mac.mm

 // Copyright 2014 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 "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/message_loop/message_loop.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "ui/accelerated_widget_mac/surface_handle_types.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gl/scoped_cgl.h"
 
 @interface CALayer (PrivateAPI)
 - (void)setContentsChanged;
 @end
 
 namespace ui {
 namespace {
@@ skipping 102 matching lines @@
   return false;
 }
 
 void AcceleratedWidgetMac::BeginPumpingFrames() {
 }
 
 void AcceleratedWidgetMac::EndPumpingFrames() {
 }
 
 void AcceleratedWidgetMac::GotAcceleratedFrame(
-    uint64 surface_handle,
+    CAContextID ca_context_id,
+    base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const std::vector<ui::LatencyInfo>& latency_info,
     const gfx::Size& pixel_size,
     float scale_factor,
     const gfx::Rect& pixel_damage_rect,
     const base::Closure& drawn_callback) {
   // Record the surface and latency info to use when acknowledging this frame.
   DCHECK(accelerated_frame_drawn_callback_.is_null());
   accelerated_frame_drawn_callback_ = drawn_callback;
   accelerated_latency_info_.insert(accelerated_latency_info_.end(),
                                    latency_info.begin(), latency_info.end());
 
   // If there is no view and therefore no superview to draw into, early-out.
   if (!view_) {
     AcknowledgeAcceleratedFrame();
     return;
   }
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
   last_swap_size_dip_ = gfx::ConvertSizeToDIP(scale_factor, pixel_size);
-  switch (GetSurfaceHandleType(surface_handle)) {
-    case kSurfaceHandleTypeIOSurface: {
-      IOSurfaceID io_surface_id = IOSurfaceIDFromSurfaceHandle(surface_handle);
-      GotAcceleratedIOSurfaceFrame(io_surface_id, pixel_size, scale_factor);
-      break;
-    }
-    case kSurfaceHandleTypeCAContext: {
-      CAContextID ca_context_id = CAContextIDFromSurfaceHandle(surface_handle);
-      GotAcceleratedCAContextFrame(ca_context_id, pixel_size, scale_factor);
-      break;
-    }
-    default:
-      DLOG(ERROR) << "Unrecognized accelerated frame type.";
-      return;
-  }
+
+  if (ca_context_id)
+    GotAcceleratedCAContextFrame(ca_context_id, pixel_size, scale_factor);
+  else
+    GotAcceleratedIOSurfaceFrame(io_surface, pixel_size, scale_factor);
 
   AcknowledgeAcceleratedFrame();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedCAContextFrame(
     CAContextID ca_context_id,
     const gfx::Size& pixel_size,
     float scale_factor) {
   // In the layer is replaced, keep the old one around until after the new one
   // is installed to avoid flashes.
@@ skipping 13 matching lines @@
   // If this replacing a same-type layer, remove it now that the new layer is
   // in the hierarchy.
   if (old_ca_context_layer != ca_context_layer_)
     DestroyCAContextLayer(old_ca_context_layer);
 
   // Remove any different-type layers that this is replacing.
   DestroyLocalLayer();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedIOSurfaceFrame(
-    IOSurfaceID io_surface_id,
+    base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const gfx::Size& pixel_size,
     float scale_factor) {
-  base::ScopedCFTypeRef<IOSurfaceRef> io_surface(
-      IOSurfaceLookup(io_surface_id));
-  GotIOSurfaceFrame(io_surface, pixel_size, scale_factor, true);
+  GotIOSurfaceFrame(io_surface, pixel_size, scale_factor, false);
 }
 
 void AcceleratedWidgetMac::EnsureLocalLayer() {
   if (!local_layer_) {
     local_layer_.reset([[CALayer alloc] init]);
     // Setting contents gravity is necessary to prevent the layer from being
     // scaled during dyanmic resizes (especially with devtools open).
     [local_layer_ setContentsGravity:kCAGravityTopLeft];
     [flipped_layer_ addSublayer:local_layer_];
   }
@@ skipping 59 matching lines @@
   if (accelerated_frame_drawn_callback_.is_null())
     return;
   accelerated_frame_drawn_callback_.Run();
   accelerated_frame_drawn_callback_.Reset();
   if (view_)
     view_->AcceleratedWidgetSwapCompleted(accelerated_latency_info_);
   accelerated_latency_info_.clear();
 }
 
 void AcceleratedWidgetMacGotAcceleratedFrame(
-    gfx::AcceleratedWidget widget, uint64 surface_handle,
+    gfx::AcceleratedWidget widget,
+    CAContextID ca_context_id,
+    base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const std::vector<ui::LatencyInfo>& latency_info,
     const gfx::Size& pixel_size,
     float scale_factor,
     const gfx::Rect& pixel_damage_rect,
     const base::Closure& drawn_callback,
-    bool* disable_throttling, int* renderer_id,
-    base::TimeTicks* vsync_timebase, base::TimeDelta* vsync_interval) {
+    bool* disable_throttling,
+    int* renderer_id,
+    base::TimeTicks* vsync_timebase,
+    base::TimeDelta* vsync_interval) {
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
   if (accelerated_widget_mac) {
     accelerated_widget_mac->GotAcceleratedFrame(
-        surface_handle, latency_info, pixel_size, scale_factor,
+        ca_context_id, io_surface, latency_info, pixel_size, scale_factor,
         pixel_damage_rect, drawn_callback);
     *disable_throttling =
         accelerated_widget_mac->IsRendererThrottlingDisabled();
     *renderer_id = accelerated_widget_mac->GetRendererID();
     accelerated_widget_mac->GetVSyncParameters(vsync_timebase, vsync_interval);
   } else {
     *disable_throttling = false;
     *renderer_id = 0;
     *vsync_timebase = base::TimeTicks();
     *vsync_interval = base::TimeDelta();
   }
 }
 
 void AcceleratedWidgetMacGotIOSurfaceFrame(
     gfx::AcceleratedWidget widget,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const gfx::Size& pixel_size,
     float scale_factor,
     bool flip_y) {
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
   if (accelerated_widget_mac) {
     accelerated_widget_mac->GotIOSurfaceFrame(io_surface, pixel_size,
                                               scale_factor, flip_y);
   }
 }
 
 }  // namespace ui