refactor: move devtools from brightray to atom (#15234)

atom/browser/ui/cocoa/atom_inspectable_web_contents_view.h

@@ -0,0 +1,47 @@
+// Copyright (c) 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-CHROMIUM file.
+
+#ifndef ATOM_BROWSER_UI_COCOA_BRY_INSPECTABLE_WEB_CONTENTS_VIEW_H_
+#define ATOM_BROWSER_UI_COCOA_BRY_INSPECTABLE_WEB_CONTENTS_VIEW_H_
+
+#import <AppKit/AppKit.h>
+
+#include "base/mac/scoped_nsobject.h"
+#include "chrome/browser/devtools/devtools_contents_resizing_strategy.h"
+#include "ui/base/cocoa/base_view.h"
+
+namespace atom {
+class InspectableWebContentsViewMac;
+}
+
+using atom::InspectableWebContentsViewMac;
+
+@interface AtomInspectableWebContentsView : BaseView <NSWindowDelegate> {
+ @private
+  atom::InspectableWebContentsViewMac* inspectableWebContentsView_;
+
+  base::scoped_nsobject<NSView> fake_view_;
+  base::scoped_nsobject<NSWindow> devtools_window_;
+  BOOL devtools_visible_;
+  BOOL devtools_docked_;
+  BOOL devtools_is_first_responder_;
+
+  DevToolsContentsResizingStrategy strategy_;
+}
+
+- (instancetype)initWithInspectableWebContentsViewMac:
+    (InspectableWebContentsViewMac*)view;
+- (void)removeObservers;
+- (void)notifyDevToolsFocused;
+- (void)setDevToolsVisible:(BOOL)visible;
+- (BOOL)isDevToolsVisible;
+- (BOOL)isDevToolsFocused;
+- (void)setIsDocked:(BOOL)docked;
+- (void)setContentsResizingStrategy:
+    (const DevToolsContentsResizingStrategy&)strategy;
+- (void)setTitle:(NSString*)title;
+
+@end
+
+#endif  // ATOM_BROWSER_UI_COCOA_BRY_INSPECTABLE_WEB_CONTENTS_VIEW_H_

atom/browser/ui/cocoa/atom_inspectable_web_contents_view.mm

@@ -0,0 +1,273 @@
+// Copyright (c) 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-CHROMIUM file.
+
+#include "atom/browser/ui/cocoa/atom_inspectable_web_contents_view.h"
+
+#include "atom/browser/ui/cocoa/event_dispatching_window.h"
+#include "atom/browser/ui/inspectable_web_contents_impl.h"
+#include "atom/browser/ui/inspectable_web_contents_view_delegate.h"
+#include "atom/browser/ui/inspectable_web_contents_view_mac.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "ui/gfx/mac/scoped_cocoa_disable_screen_updates.h"
+
+@implementation AtomInspectableWebContentsView
+
+- (instancetype)initWithInspectableWebContentsViewMac:
+    (InspectableWebContentsViewMac*)view {
+  self = [super init];
+  if (!self)
+    return nil;
+
+  inspectableWebContentsView_ = view;
+  devtools_visible_ = NO;
+  devtools_docked_ = NO;
+  devtools_is_first_responder_ = NO;
+
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(viewDidBecomeFirstResponder:)
+             name:kViewDidBecomeFirstResponder
+           object:nil];
+
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(parentWindowBecameMain:)
+             name:NSWindowDidBecomeMainNotification
+           object:nil];
+
+  if (inspectableWebContentsView_->inspectable_web_contents()->IsGuest()) {
+    fake_view_.reset([[NSView alloc] init]);
+    [fake_view_ setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+    [self addSubview:fake_view_];
+  } else {
+    auto* contents = inspectableWebContentsView_->inspectable_web_contents()
+                         ->GetWebContents();
+    auto contentsView = contents->GetNativeView();
+    [contentsView setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+    [self addSubview:contentsView];
+  }
+
+  // See https://code.google.com/p/chromium/issues/detail?id=348490.
+  [self setWantsLayer:YES];
+
+  return self;
+}
+
+- (void)removeObservers {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)resizeSubviewsWithOldSize:(NSSize)oldBoundsSize {
+  [self adjustSubviews];
+}
+
+- (IBAction)showDevTools:(id)sender {
+  inspectableWebContentsView_->inspectable_web_contents()->ShowDevTools();
+}
+
+- (void)notifyDevToolsFocused {
+  if (inspectableWebContentsView_->GetDelegate())
+    inspectableWebContentsView_->GetDelegate()->DevToolsFocused();
+}
+
+- (void)setDevToolsVisible:(BOOL)visible {
+  if (visible == devtools_visible_)
+    return;
+
+  auto* inspectable_web_contents =
+      inspectableWebContentsView_->inspectable_web_contents();
+  auto* webContents = inspectable_web_contents->GetWebContents();
+  auto* devToolsWebContents =
+      inspectable_web_contents->GetDevToolsWebContents();
+  auto devToolsView = devToolsWebContents->GetNativeView();
+
+  if (visible && devtools_docked_) {
+    webContents->SetAllowOtherViews(true);
+    devToolsWebContents->SetAllowOtherViews(true);
+  } else if (!inspectable_web_contents->IsGuest()) {
+    webContents->SetAllowOtherViews(false);
+  }
+
+  devtools_visible_ = visible;
+  if (devtools_docked_) {
+    if (visible) {
+      // Place the devToolsView under contentsView, notice that we didn't set
+      // sizes for them until the setContentsResizingStrategy message.
+      [self addSubview:devToolsView positioned:NSWindowBelow relativeTo:nil];
+      [self adjustSubviews];
+
+      // Focus on web view.
+      devToolsWebContents->RestoreFocus();
+    } else {
+      gfx::ScopedCocoaDisableScreenUpdates disabler;
+      [devToolsView removeFromSuperview];
+      [self adjustSubviews];
+    }
+  } else {
+    if (visible) {
+      [devtools_window_ makeKeyAndOrderFront:nil];
+    } else {
+      [devtools_window_ setDelegate:nil];
+      [devtools_window_ close];
+      devtools_window_.reset();
+    }
+  }
+}
+
+- (BOOL)isDevToolsVisible {
+  return devtools_visible_;
+}
+
+- (BOOL)isDevToolsFocused {
+  if (devtools_docked_) {
+    return [[self window] isKeyWindow] && devtools_is_first_responder_;
+  } else {
+    return [devtools_window_ isKeyWindow];
+  }
+}
+
+- (void)setIsDocked:(BOOL)docked {
+  // Revert to no-devtools state.
+  [self setDevToolsVisible:NO];
+
+  // Switch to new state.
+  devtools_docked_ = docked;
+  if (!docked) {
+    auto* inspectable_web_contents =
+        inspectableWebContentsView_->inspectable_web_contents();
+    auto* devToolsWebContents =
+        inspectable_web_contents->GetDevToolsWebContents();
+    auto devToolsView = devToolsWebContents->GetNativeView();
+
+    auto styleMask = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
+                     NSMiniaturizableWindowMask | NSWindowStyleMaskResizable |
+                     NSTexturedBackgroundWindowMask |
+                     NSWindowStyleMaskUnifiedTitleAndToolbar;
+    devtools_window_.reset([[EventDispatchingWindow alloc]
+        initWithContentRect:NSMakeRect(0, 0, 800, 600)
+                  styleMask:styleMask
+                    backing:NSBackingStoreBuffered
+                      defer:YES]);
+    [devtools_window_ setDelegate:self];
+    [devtools_window_ setFrameAutosaveName:@"brightray.devtools"];
+    [devtools_window_ setTitle:@"Developer Tools"];
+    [devtools_window_ setReleasedWhenClosed:NO];
+    [devtools_window_ setAutorecalculatesContentBorderThickness:NO
+                                                        forEdge:NSMaxYEdge];
+    [devtools_window_ setContentBorderThickness:24 forEdge:NSMaxYEdge];
+
+    NSView* contentView = [devtools_window_ contentView];
+    devToolsView.frame = contentView.bounds;
+    devToolsView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+
+    [contentView addSubview:devToolsView];
+  }
+  [self setDevToolsVisible:YES];
+}
+
+- (void)setContentsResizingStrategy:
+    (const DevToolsContentsResizingStrategy&)strategy {
+  strategy_.CopyFrom(strategy);
+  [self adjustSubviews];
+}
+
+- (void)adjustSubviews {
+  if (![[self subviews] count])
+    return;
+
+  if (![self isDevToolsVisible] || devtools_window_) {
+    DCHECK_EQ(1u, [[self subviews] count]);
+    NSView* contents = [[self subviews] objectAtIndex:0];
+    [contents setFrame:[self bounds]];
+    return;
+  }
+
+  NSView* devToolsView = [[self subviews] objectAtIndex:0];
+  NSView* contentsView = [[self subviews] objectAtIndex:1];
+
+  DCHECK_EQ(2u, [[self subviews] count]);
+
+  gfx::Rect new_devtools_bounds;
+  gfx::Rect new_contents_bounds;
+  ApplyDevToolsContentsResizingStrategy(
+      strategy_, gfx::Size(NSSizeToCGSize([self bounds].size)),
+      &new_devtools_bounds, &new_contents_bounds);
+  [devToolsView setFrame:[self flipRectToNSRect:new_devtools_bounds]];
+  [contentsView setFrame:[self flipRectToNSRect:new_contents_bounds]];
+}
+
+- (void)setTitle:(NSString*)title {
+  [devtools_window_ setTitle:title];
+}
+
+- (void)viewDidBecomeFirstResponder:(NSNotification*)notification {
+  auto* inspectable_web_contents =
+      inspectableWebContentsView_->inspectable_web_contents();
+  if (!inspectable_web_contents || inspectable_web_contents->IsGuest())
+    return;
+  auto* webContents = inspectable_web_contents->GetWebContents();
+  auto webContentsView = webContents->GetNativeView();
+
+  NSView* view = [notification object];
+  if ([[webContentsView subviews] containsObject:view]) {
+    devtools_is_first_responder_ = NO;
+    return;
+  }
+
+  auto* devToolsWebContents =
+      inspectable_web_contents->GetDevToolsWebContents();
+  if (!devToolsWebContents)
+    return;
+  auto devToolsView = devToolsWebContents->GetNativeView();
+
+  if ([[devToolsView subviews] containsObject:view]) {
+    devtools_is_first_responder_ = YES;
+    [self notifyDevToolsFocused];
+  }
+}
+
+- (void)parentWindowBecameMain:(NSNotification*)notification {
+  NSWindow* parentWindow = [notification object];
+  if ([self window] == parentWindow && devtools_docked_ &&
+      devtools_is_first_responder_)
+    [self notifyDevToolsFocused];
+}
+
+#pragma mark - NSWindowDelegate
+
+- (void)windowWillClose:(NSNotification*)notification {
+  inspectableWebContentsView_->inspectable_web_contents()->CloseDevTools();
+}
+
+- (void)windowDidBecomeMain:(NSNotification*)notification {
+  content::WebContents* web_contents =
+      inspectableWebContentsView_->inspectable_web_contents()
+          ->GetDevToolsWebContents();
+  if (!web_contents)
+    return;
+
+  web_contents->RestoreFocus();
+
+  content::RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(true);
+
+  [self notifyDevToolsFocused];
+}
+
+- (void)windowDidResignMain:(NSNotification*)notification {
+  content::WebContents* web_contents =
+      inspectableWebContentsView_->inspectable_web_contents()
+          ->GetDevToolsWebContents();
+  if (!web_contents)
+    return;
+
+  web_contents->StoreFocus();
+
+  content::RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(false);
+}
+
+@end

atom/browser/ui/cocoa/atom_ns_window.h

@@ -5,7 +5,7 @@
 #ifndef ATOM_BROWSER_UI_COCOA_ATOM_NS_WINDOW_H_
 #define ATOM_BROWSER_UI_COCOA_ATOM_NS_WINDOW_H_
 
-#include "brightray/browser/mac/event_dispatching_window.h"
+#include "atom/browser/ui/cocoa/event_dispatching_window.h"
 #include "ui/views/cocoa/native_widget_mac_nswindow.h"
 #include "ui/views/widget/native_widget_mac.h"
 

atom/browser/ui/cocoa/event_dispatching_window.h

@@ -0,0 +1,19 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_UI_COCOA_EVENT_DISPATCHING_WINDOW_H_
+#define ATOM_BROWSER_UI_COCOA_EVENT_DISPATCHING_WINDOW_H_
+
+#import "ui/base/cocoa/underlay_opengl_hosting_window.h"
+
+@interface EventDispatchingWindow : UnderlayOpenGLHostingWindow {
+ @private
+  BOOL redispatchingEvent_;
+}
+
+- (void)redispatchKeyEvent:(NSEvent*)event;
+
+@end
+
+#endif  // ATOM_BROWSER_UI_COCOA_EVENT_DISPATCHING_WINDOW_H_

atom/browser/ui/cocoa/event_dispatching_window.mm

@@ -0,0 +1,34 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/ui/cocoa/event_dispatching_window.h"
+
+@implementation EventDispatchingWindow
+
+- (void)sendEvent:(NSEvent*)event {
+  if (!redispatchingEvent_)
+    [super sendEvent:event];
+}
+
+- (BOOL)performKeyEquivalent:(NSEvent*)event {
+  if (redispatchingEvent_)
+    return NO;
+  else
+    return [super performKeyEquivalent:event];
+}
+
+- (void)redispatchKeyEvent:(NSEvent*)event {
+  NSEventType eventType = [event type];
+  if (eventType != NSKeyDown && eventType != NSKeyUp &&
+      eventType != NSFlagsChanged) {
+    return;
+  }
+
+  // Redispatch the event.
+  redispatchingEvent_ = YES;
+  [NSApp sendEvent:event];
+  redispatchingEvent_ = NO;
+}
+
+@end