Mac: Only allow NSOpenGLContext displaying on the main display

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/command_line.h"
 #include "base/lazy_instance.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/io_surface_layer.h"
 #include "ui/accelerated_widget_mac/io_surface_ns_gl_surface.h"
 #include "ui/accelerated_widget_mac/surface_handle_types.h"
 #include "ui/base/cocoa/animation_utils.h"
-#include "ui/base/ui_base_switches.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gl/scoped_cgl.h"
 
 namespace ui {
 namespace {
 
 typedef std::map<gfx::AcceleratedWidget,AcceleratedWidgetMac*>
     WidgetToHelperMap;
 base::LazyInstance<WidgetToHelperMap> g_widget_to_helper_map;
 
@@ skipping 60 matching lines @@
 void AcceleratedWidgetMac::ResetNSView() {
   if (!view_)
     return;
 
   // Disable the fade-out animation as the view is removed.
   ScopedCAActionDisabler disabler;
 
   [flipped_layer_ removeFromSuperlayer];
   DestroyIOSurfaceLayer(io_surface_layer_);
   DestroyCAContextLayer(ca_context_layer_);
+  DestroyIOSurfaceNSGLSurface();
   DestroySoftwareLayer();
-  io_surface_ns_gl_surface_.reset();
 
   last_swap_size_dip_ = gfx::Size();
   view_ = NULL;
 }
 
 bool AcceleratedWidgetMac::HasFrameOfSize(
     const gfx::Size& dip_size) const {
   return last_swap_size_dip_ == dip_size;
 }
 
 int AcceleratedWidgetMac::GetRendererID() const {
   if (io_surface_layer_)
     return [io_surface_layer_ rendererID];
+  if (io_surface_ns_gl_surface_)
+    return io_surface_ns_gl_surface_->GetRendererID();
   return 0;
 }
 
 bool AcceleratedWidgetMac::IsRendererThrottlingDisabled() const {
   if (view_)
     return view_->AcceleratedWidgetShouldIgnoreBackpressure();
   return false;
 }
 
 void AcceleratedWidgetMac::BeginPumpingFrames() {
   [io_surface_layer_ beginPumpingFrames];
 }
 
 void AcceleratedWidgetMac::EndPumpingFrames() {
   [io_surface_layer_ endPumpingFrames];
 }
 
 void AcceleratedWidgetMac::GotAcceleratedFrame(
     uint64 surface_handle,
     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) {
-  static bool use_ns_gl_surfaces =
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableNSGLSurfaces);
-
   // 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);
-      if (use_ns_gl_surfaces) {
+      if (IOSurfaceNSGLSurface::CanUseNSGLSurfaceForView(
+              view_->AcceleratedWidgetGetNSView())) {
         GotAcceleratedIOSurfaceFrameNSGL(
             io_surface_id, pixel_size, scale_factor, pixel_damage_rect);
       } else {
         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);
@@ skipping 28 matching lines @@
   // process will do any required throttling).
   AcknowledgeAcceleratedFrame();
 
   // 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.
   DestroyIOSurfaceLayer(io_surface_layer_);
+  DestroyIOSurfaceNSGLSurface();
   DestroySoftwareLayer();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedIOSurfaceFrameNSGL(
     IOSurfaceID io_surface_id,
     const gfx::Size& pixel_size,
     float scale_factor,
     const gfx::Rect& pixel_damage_rect) {
-  if (!io_surface_ns_gl_surface_) {
+  if (!io_surface_ns_gl_surface_ ||
+      io_surface_ns_gl_surface_->NeedsToBeRecreated()) {
     io_surface_ns_gl_surface_.reset(
         IOSurfaceNSGLSurface::Create(
-            this, view_->AcceleratedWidgetGetNSView()));
+            this,
+            view_->AcceleratedWidgetGetNSView(),
+            needs_gl_finish_workaround_));
   }
 
   if (!io_surface_ns_gl_surface_) {
     LOG(ERROR) << "Failed to create IOSurfaceNSGLSurface";
     AcknowledgeAcceleratedFrame();
     return;
   }
 
   io_surface_ns_gl_surface_->GotFrame(
       io_surface_id, pixel_size, scale_factor, pixel_damage_rect);
+
+  // Remove any different-type layers that this is replacing.
+  DestroyCAContextLayer(ca_context_layer_);
+  DestroyIOSurfaceLayer(io_surface_layer_);
+  DestroySoftwareLayer();
 }
 
 void AcceleratedWidgetMac::GotAcceleratedIOSurfaceFrame(
     IOSurfaceID io_surface_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.
   base::scoped_nsobject<IOSurfaceLayer> old_io_surface_layer =
       io_surface_layer_;
@@ skipping 50 matching lines @@
       [io_surface_layer_ setNeedsDisplayAndDisplayAndAck];
   }
 
   // If this replacing a same-type layer, remove it now that the new layer is
   // in the hierarchy.
   if (old_io_surface_layer != io_surface_layer_)
     DestroyIOSurfaceLayer(old_io_surface_layer);
 
   // Remove any different-type layers that this is replacing.
   DestroyCAContextLayer(ca_context_layer_);
+  DestroyIOSurfaceNSGLSurface();
   DestroySoftwareLayer();
-  io_surface_ns_gl_surface_.reset();
 }
 
 void AcceleratedWidgetMac::GotSoftwareFrame(float scale_factor,
                                             SkCanvas* canvas) {
   if (!canvas || !view_)
     return;
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
@@ skipping 10 matching lines @@
   gfx::Size pixel_size(info.width(), info.height());
   [software_layer_ setContentsToData:pixels
                         withRowBytes:row_bytes
                        withPixelSize:pixel_size
                      withScaleFactor:scale_factor];
   last_swap_size_dip_ = gfx::ConvertSizeToDIP(scale_factor, pixel_size);
 
   // Remove any different-type layers that this is replacing.
   DestroyCAContextLayer(ca_context_layer_);
   DestroyIOSurfaceLayer(io_surface_layer_);
+  DestroyIOSurfaceNSGLSurface();
 }
 
 void AcceleratedWidgetMac::DestroyCAContextLayer(
     base::scoped_nsobject<CALayerHost> ca_context_layer) {
   if (!ca_context_layer)
     return;
   [ca_context_layer removeFromSuperlayer];
   if (ca_context_layer == ca_context_layer_)
     ca_context_layer_.reset();
 }
 
 void AcceleratedWidgetMac::DestroyIOSurfaceLayer(
     base::scoped_nsobject<IOSurfaceLayer> io_surface_layer) {
   if (!io_surface_layer)
     return;
   [io_surface_layer resetClient];
   [io_surface_layer removeFromSuperlayer];
   if (io_surface_layer == io_surface_layer_)
     io_surface_layer_.reset();
 }
 
+void AcceleratedWidgetMac::DestroyIOSurfaceNSGLSurface() {
+  io_surface_ns_gl_surface_.reset();
+}
+
 void AcceleratedWidgetMac::DestroySoftwareLayer() {
   if (!software_layer_)
     return;
   [software_layer_ removeFromSuperlayer];
   software_layer_.reset();
 }
 
 bool AcceleratedWidgetMac::IOSurfaceLayerShouldAckImmediately() const {
   // If there is no view then the accelerated layer is not in the view
   // hierarchy and will never draw.
@@ skipping 57 matching lines @@
 
 void AcceleratedWidgetMacGotSoftwareFrame(
     gfx::AcceleratedWidget widget, float scale_factor, SkCanvas* canvas) {
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
   if (accelerated_widget_mac)
     accelerated_widget_mac->GotSoftwareFrame(scale_factor, canvas);
 }
 
 }  // namespace ui