Add detached mode plumbing

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/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/sdk_forward_declarations.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/base/cocoa/animation_utils.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gl/scoped_cgl.h"
 
+@interface DetachedModeWindow : NSWindow {
+  base::WeakPtr<ui::AcceleratedWidgetMac> accelerated_widget_mac_;
+  base::scoped_nsobject<NSWindow> target_window_;
+}
+
+- (id)initWithAcceleratedWidgetMac:
+    (base::WeakPtr<ui::AcceleratedWidgetMac>)accelerated_widget_mac;
+- (void)startForwardingEvents:(NSWindow*)target_window;
+- (void)stopForwardingEvents;
+@end
+
+@implementation DetachedModeWindow : NSWindow
+- (id)initWithAcceleratedWidgetMac:
+    (base::WeakPtr<ui::AcceleratedWidgetMac>)accelerated_widget_mac {
+  if (self = [super
+          initWithContentRect:NSMakeRect(0, 0, 100, 100)
+                    styleMask:NSTitledWindowMask | NSResizableWindowMask |
+                              NSFullSizeContentViewWindowMask
+                      backing:NSBackingStoreBuffered
+                        defer:NO]) {
+    [self setReleasedWhenClosed:NO];
+    accelerated_widget_mac_ = accelerated_widget_mac;
+    return self;
+  }
+  return nil;
+}
+
+- (void)startForwardingEvents:(NSWindow*)target_window {
+  target_window_.reset([target_window retain]);
+}
+
+- (void)stopForwardingEvents {
+  target_window_.reset();
+}
+
+- (void)close {
+  if (accelerated_widget_mac_)
+    accelerated_widget_mac_->DestroyDetachedModeWindow();
+  [super close];
+}
+
+- (void)sendEvent:(NSEvent*)event {
+  // This doesn't actually fix the issue for mouse move. Eh.
+  if (target_window_) 
+    [target_window_ sendEvent:event];
+}
+@end
+
+@interface NSWindowController (HorribleHack)
+- (void)setDetachedVideoLayer:(base::scoped_nsobject<CALayer>)layer;
+@end
+
 @interface CALayer (PrivateAPI)
 - (void)setContentsChanged;
 @end
 
 namespace ui {
 namespace {
 
 typedef std::map<gfx::AcceleratedWidget,AcceleratedWidgetMac*>
     WidgetToHelperMap;
 base::LazyInstance<WidgetToHelperMap> g_widget_to_helper_map;
 
 AcceleratedWidgetMac* GetHelperFromAcceleratedWidget(
     gfx::AcceleratedWidget widget) {
   WidgetToHelperMap::const_iterator found =
       g_widget_to_helper_map.Pointer()->find(widget);
   // This can end up being accessed after the underlying widget has been
   // destroyed, but while the ui::Compositor is still being destroyed.
   // Return NULL in these cases.
   if (found == g_widget_to_helper_map.Pointer()->end())
     return NULL;
   return found->second;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // AcceleratedWidgetMac
 
-AcceleratedWidgetMac::AcceleratedWidgetMac() : view_(nullptr) {
+AcceleratedWidgetMac::AcceleratedWidgetMac()
+    : view_(nullptr), weak_factory_(this) {
   // Disable the fade-in animation as the layers are added.
   ScopedCAActionDisabler disabler;
 
   // Add a flipped transparent layer as a child, so that we don't need to
   // fiddle with the position of sub-layers -- they will always be at the
   // origin.
   flipped_layer_.reset([[CALayer alloc] init]);
   [flipped_layer_ setGeometryFlipped:YES];
   [flipped_layer_ setAnchorPoint:CGPointMake(0, 0)];
   [flipped_layer_
@@ skipping 53 matching lines @@
     view_->AcceleratedWidgetGetVSyncParameters(timebase, interval);
   } else {
     *timebase = base::TimeTicks();
     *interval = base::TimeDelta();
   }
 }
 
 void AcceleratedWidgetMac::GotFrame(
     CAContextID ca_context_id,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    bool use_detached_mode,
+    CAContextID detached_ca_context_id,
     const gfx::Size& pixel_size,
     float scale_factor) {
   TRACE_EVENT0("ui", "AcceleratedWidgetMac::GotFrame");
 
   // If there is no view and therefore no superview to draw into, early-out.
   if (!view_) {
     TRACE_EVENT0("ui", "No associated NSView");
     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);
 
   if (ca_context_id)
-    GotCAContextFrame(ca_context_id, pixel_size, scale_factor);
+    GotCAContextFrame(ca_context_id, use_detached_mode, detached_ca_context_id,
+                      pixel_size, scale_factor);
   else
     GotIOSurfaceFrame(io_surface, pixel_size, scale_factor);
 
+  if (use_detached_mode)
+    EnterDetachedMode();
+  else
+    LeaveDetachedMode();
+
   view_->AcceleratedWidgetSwapCompleted();
 }
 
 void AcceleratedWidgetMac::GotCAContextFrame(CAContextID ca_context_id,
+                                             bool use_detached,
+                                             CAContextID detached_ca_context_id,
                                              const gfx::Size& pixel_size,
                                              float scale_factor) {
   TRACE_EVENT0("ui", "AcceleratedWidgetMac::GotCAContextFrame");
 
   // In the layer is replaced, keep the old one around until after the new one
   // is installed to avoid flashes.
   base::scoped_nsobject<CALayerHost> old_ca_context_layer =
       ca_context_layer_;
 
   // Create the layer to host the layer exported by the GPU process with this
   // particular CAContext ID.
   if ([ca_context_layer_ contextId] != ca_context_id) {
     TRACE_EVENT0("ui", "Creating a new CALayerHost");
     ca_context_layer_.reset([[CALayerHost alloc] init]);
     [ca_context_layer_ setContextId:ca_context_id];
     [ca_context_layer_
         setAutoresizingMask:kCALayerMaxXMargin|kCALayerMaxYMargin];
     [flipped_layer_ addSublayer:ca_context_layer_];
   }
 
+  if ([detached_ca_context_layer_ contextId] != detached_ca_context_id) {
+    TRACE_EVENT0("ui", "Creating a new CALayerHost");
+    detached_ca_context_layer_.reset([[CALayerHost alloc] init]);
+    [detached_ca_context_layer_ setContextId:detached_ca_context_id];
+    [detached_ca_context_layer_
+        setAutoresizingMask:kCALayerMaxXMargin | kCALayerMaxYMargin];
+  }
+
   // 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::EnsureLocalLayer() {
@@ skipping 51 matching lines @@
   if (!local_layer_)
     return;
   [local_layer_ removeFromSuperlayer];
   local_layer_.reset();
 }
 
 void AcceleratedWidgetMacGotFrame(
     gfx::AcceleratedWidget widget,
     CAContextID ca_context_id,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    bool use_detached,
+    CAContextID detached_ca_context_id,
     const gfx::Size& pixel_size,
     float scale_factor,
     base::TimeTicks* vsync_timebase,
     base::TimeDelta* vsync_interval) {
   if (vsync_timebase)
     *vsync_timebase = base::TimeTicks();
   if (vsync_interval)
     *vsync_interval = base::TimeDelta();
 
   AcceleratedWidgetMac* accelerated_widget_mac =
       GetHelperFromAcceleratedWidget(widget);
 
   if (accelerated_widget_mac) {
-    accelerated_widget_mac->GotFrame(ca_context_id, io_surface, pixel_size,
+    accelerated_widget_mac->GotFrame(ca_context_id, io_surface, use_detached,
+                                     detached_ca_context_id, pixel_size,
                                      scale_factor);
     if (vsync_timebase && vsync_interval) {
       accelerated_widget_mac->GetVSyncParameters(vsync_timebase,
                                                  vsync_interval);
     }
   }
 }
 
+NSWindow* AcceleratedWidgetMac::CreateDetachedModeWindow() {
+  DCHECK(!detached_mode_window_);
+
+  detached_mode_window_.reset([[DetachedModeWindow alloc]
+      initWithAcceleratedWidgetMac:weak_factory_.GetWeakPtr()]);
+
+  NSView* view = [detached_mode_window_ contentView];
+  base::scoped_nsobject<CALayer> background_layer([[CALayer alloc] init]);
+  [background_layer setBackgroundColor:CGColorGetConstantColor(kCGColorBlack)];
+  [view setLayer:background_layer];
+  [view setWantsLayer:YES];
+  [background_layer addSublayer:detached_ca_context_layer_];
+  return [detached_mode_window_ retain];
+}
+
+void AcceleratedWidgetMac::EnterDetachedMode() {
+  if (!detached_mode_window_ || in_detached_mode_)
+    return;
+  in_detached_mode_ = true;
+  NSWindow* view_window = [view_->AcceleratedWidgetGetNSView() window];
+  [detached_mode_window_ setFrame:[view_window frame] display:YES];
+  [detached_mode_window_
+      setStyleMask:[detached_mode_window_ styleMask] | NSFullScreenWindowMask];
+  // FIXME: This causes events to not be forwarded to the correct window.
+  [detached_mode_window_ orderWindow:NSWindowAbove
+                          relativeTo:[view_window windowNumber]];
+  [detached_mode_window_ startForwardingEvents:view_window];
+}
+
+void AcceleratedWidgetMac::LeaveDetachedMode() {
+  if (!detached_mode_window_ || !in_detached_mode_)
+    return;
+  in_detached_mode_ = false;
+  NSWindow* view_window = [view_->AcceleratedWidgetGetNSView() window];
+  [detached_mode_window_ orderWindow:NSWindowBelow
+                          relativeTo:[view_window windowNumber]];
+  [detached_mode_window_ stopForwardingEvents];
+}
+
+void AcceleratedWidgetMac::DestroyDetachedModeWindow() {
+  LeaveDetachedMode();
+  detached_mode_window_.reset();
+}
+
 }  // namespace ui