#include "shell/browser/native_window_mac.h"

#include <AvailabilityMacros.h>

#include <objc/objc-runtime.h>

#include <algorithm>

#include <string>

#include <utility>

#include <vector>

#include "base/cxx17_backports.h"

#include "base/mac/mac_util.h"

#include "base/mac/scoped_cftyperef.h"

#include "base/strings/sys_string_conversions.h"

#include "base/task/post_task.h"

#include "components/remote_cocoa/app_shim/native_widget_ns_window_bridge.h"

#include "components/remote_cocoa/browser/scoped_cg_window_id.h"

#include "content/public/browser/browser_accessibility_state.h"

#include "content/public/browser/browser_task_traits.h"

#include "content/public/browser/browser_thread.h"

#include "content/public/browser/desktop_media_id.h"

#include "shell/browser/javascript_environment.h"

#include "shell/browser/native_browser_view_mac.h"

#include "shell/browser/ui/cocoa/electron_native_widget_mac.h"

#include "shell/browser/ui/cocoa/electron_ns_window.h"

#include "shell/browser/ui/cocoa/electron_ns_window_delegate.h"

#include "shell/browser/ui/cocoa/electron_preview_item.h"

#include "shell/browser/ui/cocoa/electron_touch_bar.h"

#include "shell/browser/ui/cocoa/root_view_mac.h"

#include "shell/browser/ui/cocoa/window_buttons_proxy.h"

#include "shell/browser/ui/inspectable_web_contents.h"

#include "shell/browser/ui/inspectable_web_contents_view.h"

#include "shell/browser/window_list.h"

#include "shell/common/gin_converters/gfx_converter.h"

#include "shell/common/gin_helper/dictionary.h"

#include "shell/common/node_includes.h"

#include "shell/common/options_switches.h"

#include "shell/common/process_util.h"

#include "skia/ext/skia_utils_mac.h"

#include "third_party/webrtc/modules/desktop_capture/mac/window_list_utils.h"

#include "ui/display/screen.h"

#include "ui/gfx/skia_util.h"

#include "ui/gl/gpu_switching_manager.h"

#include "ui/views/background.h"

#include "ui/views/cocoa/native_widget_mac_ns_window_host.h"

#include "ui/views/widget/widget.h"

@interface ElectronAdaptedContentView : NSView {

@private

views::NativeWidgetMacNSWindowHost* bridge_host_;

}

@implementation ElectronAdaptedContentView

- (id)initWithShell:(electron::NativeWindowMac*)shell {

if ((self = [self init])) {

bridge_host_ = views::NativeWidgetMacNSWindowHost::GetFromNativeWindow(

shell->GetNativeWindow());

}

return self;

}

- (void)viewDidMoveToWindow {

// When this view is added to a window, AppKit calls setFrameSize before it is

// added to the window, so the behavior in setFrameSize is not triggered.

NSWindow* window = [self window];

if (window)

[self setFrameSize:NSZeroSize];

}

- (void)setFrameSize:(NSSize)newSize {

// The size passed in here does not always use

// -[NSWindow contentRectForFrameRect]. The following ensures that the

// contentView for a frameless window can extend over the titlebar of the new

// window containing it, since AppKit requires a titlebar to give frameless

// windows correct shadows and rounded corners.

NSWindow* window = [self window];

if (window && [window contentView] == self) {

newSize = [window contentRectForFrameRect:[window frame]].size;

// Ensure that the window geometry be updated on the host side before the

// view size is updated.

bridge_host_->GetInProcessNSWindowBridge()->UpdateWindowGeometry();

}

[super setFrameSize:newSize];

// The OnViewSizeChanged is marked private in derived class.

static_cast<remote_cocoa::mojom::NativeWidgetNSWindowHost*>(bridge_host_)

->OnViewSizeChanged(gfx::Size(newSize.width, newSize.height));

}

@interface FullSizeContentView : NSView

@implementation FullSizeContentView

- (void)setFrameSize:(NSSize)size {

if ([self superview])

size = [[self superview] bounds].size;

[super setFrameSize:size];

}

- (void)viewDidMoveToSuperview {

[self setFrame:[[self superview] bounds]];

}

@interface ElectronProgressBar : NSProgressIndicator

@implementation ElectronProgressBar

- (void)drawRect:(NSRect)dirtyRect {

if (self.style != NSProgressIndicatorBarStyle)

return;

// Draw edges of rounded rect.

NSRect rect = NSInsetRect([self bounds], 1.0, 1.0);

CGFloat radius = rect.size.height / 2;

NSBezierPath* bezier_path = [NSBezierPath bezierPathWithRoundedRect:rect

xRadius:radius

yRadius:radius];

[bezier_path setLineWidth:2.0];

[[NSColor grayColor] set];

[bezier_path stroke];

// Fill the rounded rect.

rect = NSInsetRect(rect, 2.0, 2.0);

radius = rect.size.height / 2;

bezier_path = [NSBezierPath bezierPathWithRoundedRect:rect

xRadius:radius

yRadius:radius];

[bezier_path setLineWidth:1.0];

[bezier_path addClip];

// Calculate the progress width.

rect.size.width =

floor(rect.size.width * ([self doubleValue] / [self maxValue]));

// Fill the progress bar with color blue.

[[NSColor colorWithSRGBRed:0.2 green:0.6 blue:1 alpha:1] set];

NSRectFill(rect);

}

namespace gin {

template <>

struct Converter<electron::NativeWindowMac::VisualEffectState> {

static bool FromV8(v8::Isolate* isolate,

v8::Handle<v8::Value> val,

electron::NativeWindowMac::VisualEffectState* out) {

using VisualEffectState = electron::NativeWindowMac::VisualEffectState;

std::string visual_effect_state;

if (!ConvertFromV8(isolate, val, &visual_effect_state))

return false;

if (visual_effect_state == "followWindow") {

*out = VisualEffectState::kFollowWindow;

} else if (visual_effect_state == "active") {

*out = VisualEffectState::kActive;

} else if (visual_effect_state == "inactive") {

*out = VisualEffectState::kInactive;

} else {

return false;

}

return true;

}

};

} // namespace gin

namespace electron {

namespace {

bool IsFramelessWindow(NSView* view) {

NSWindow* nswindow = [view window];

if (![nswindow respondsToSelector:@selector(shell)])

return false;

NativeWindow* window = [static_cast<ElectronNSWindow*>(nswindow) shell];

return window && !window->has_frame();

}

IMP original_set_frame_size = nullptr;

IMP original_view_did_move_to_superview = nullptr;

void SetFrameSize(NSView* self, SEL _cmd, NSSize size) {

if (!IsFramelessWindow(self)) {

auto original =

reinterpret_cast<decltype(&SetFrameSize)>(original_set_frame_size);

return original(self, _cmd, size);

}

// For frameless window, resize the view to cover full window.

if ([self superview])

size = [[self superview] bounds].size;

auto super_impl = reinterpret_cast<decltype(&SetFrameSize)>(

[[self superclass] instanceMethodForSelector:_cmd]);

super_impl(self, _cmd, size);

}

void ViewDidMoveToSuperview(NSView* self, SEL _cmd) {

if (!IsFramelessWindow(self)) {

// [BridgedContentView viewDidMoveToSuperview];

auto original = reinterpret_cast<decltype(&ViewDidMoveToSuperview)>(

original_view_did_move_to_superview);

if (original)

original(self, _cmd);

return;

}

[self setFrame:[[self superview] bounds]];

}

} // namespace

NativeWindowMac::NativeWindowMac(const gin_helper::Dictionary& options,

NativeWindow* parent)

: NativeWindow(options, parent), root_view_(new RootViewMac(this)) {

ui::NativeTheme::GetInstanceForNativeUi()->AddObserver(this);

display::Screen::GetScreen()->AddObserver(this);

int width = 800, height = 600;

options.Get(options::kWidth, &width);

options.Get(options::kHeight, &height);

NSRect main_screen_rect = [[[NSScreen screens] firstObject] frame];

gfx::Rect bounds(round((NSWidth(main_screen_rect) - width) / 2),

round((NSHeight(main_screen_rect) - height) / 2), width,

height);

bool resizable = true;

options.Get(options::kResizable, &resizable);

options.Get(options::kZoomToPageWidth, &zoom_to_page_width_);

options.Get(options::kSimpleFullScreen, &always_simple_fullscreen_);

options.GetOptional(options::kTrafficLightPosition, &traffic_light_position_);

options.Get(options::kVisualEffectState, &visual_effect_state_);

if (options.Has(options::kFullscreenWindowTitle)) {

EmitWarning(

node::Environment::GetCurrent(JavascriptEnvironment::GetIsolate()),

"\"fullscreenWindowTitle\" option has been deprecated and is "

"no-op now.",

"electron");

}

bool minimizable = true;

options.Get(options::kMinimizable, &minimizable);

bool maximizable = true;

options.Get(options::kMaximizable, &maximizable);

bool closable = true;

options.Get(options::kClosable, &closable);

std::string tabbingIdentifier;

options.Get(options::kTabbingIdentifier, &tabbingIdentifier);

std::string windowType;

options.Get(options::kType, &windowType);

bool useStandardWindow = true;

// eventually deprecate separate "standardWindow" option in favor of

// standard / textured window types

options.Get(options::kStandardWindow, &useStandardWindow);

if (windowType == "textured") {

useStandardWindow = false;

}

// The window without titlebar is treated the same with frameless window.

if (title_bar_style_ != TitleBarStyle::kNormal)

set_has_frame(false);

NSUInteger styleMask = NSWindowStyleMaskTitled;

// Removing NSWindowStyleMaskTitled removes window title, which removes

// rounded corners of window.

bool rounded_corner = true;

options.Get(options::kRoundedCorners, &rounded_corner);

if (!rounded_corner && !has_frame())

styleMask = 0;

if (minimizable)

styleMask |= NSMiniaturizableWindowMask;

if (closable)

styleMask |= NSWindowStyleMaskClosable;

if (resizable)

styleMask |= NSResizableWindowMask;

if (!useStandardWindow || transparent() || !has_frame())

styleMask |= NSTexturedBackgroundWindowMask;

// Create views::Widget and assign window_ with it.

// TODO(zcbenz): Get rid of the window_ in future.

views::Widget::InitParams params;

params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;

params.bounds = bounds;

params.delegate = this;

params.type = views::Widget::InitParams::TYPE_WINDOW;

params.native_widget = new ElectronNativeWidgetMac(this, styleMask, widget());

widget()->Init(std::move(params));

SetCanResize(resizable);

window_ = static_cast<ElectronNSWindow*>(

widget()->GetNativeWindow().GetNativeNSWindow());

RegisterDeleteDelegateCallback(base::BindOnce(

[](NativeWindowMac* window) {

if (window->window_)

window->window_ = nil;

if (window->buttons_proxy_)

window->buttons_proxy_.reset();

},

this));

[window_ setEnableLargerThanScreen:enable_larger_than_screen()];

window_delegate_.reset([[ElectronNSWindowDelegate alloc] initWithShell:this]);

[window_ setDelegate:window_delegate_];

// Only use native parent window for non-modal windows.

if (parent && !is_modal()) {

SetParentWindow(parent);

}

if (transparent()) {

// Setting the background color to clear will also hide the shadow.

[window_ setBackgroundColor:[NSColor clearColor]];

}

if (windowType == "desktop") {

[window_ setLevel:kCGDesktopWindowLevel - 1];

[window_ setDisableKeyOrMainWindow:YES];

[window_ setCollectionBehavior:(NSWindowCollectionBehaviorCanJoinAllSpaces |

NSWindowCollectionBehaviorStationary |

NSWindowCollectionBehaviorIgnoresCycle)];

}

bool focusable;

if (options.Get(options::kFocusable, &focusable) && !focusable)

[window_ setDisableKeyOrMainWindow:YES];

if (transparent() || !has_frame()) {

// Don't show title bar.

[window_ setTitlebarAppearsTransparent:YES];

[window_ setTitleVisibility:NSWindowTitleHidden];

// Remove non-transparent corners, see http://git.io/vfonD.

[window_ setOpaque:NO];

// Show window buttons if titleBarStyle is not "normal".

if (title_bar_style_ == TitleBarStyle::kNormal) {

InternalSetWindowButtonVisibility(false);

} else {

buttons_proxy_.reset([[WindowButtonsProxy alloc] initWithWindow:window_]);

[buttons_proxy_ setHeight:titlebar_overlay_height()];

if (traffic_light_position_) {

[buttons_proxy_ setMargin:*traffic_light_position_];

} else if (title_bar_style_ == TitleBarStyle::kHiddenInset) {

// For macOS >= 11, while this value does not match official macOS apps

// like Safari or Notes, it matches titleBarStyle's old implementation

// before Electron <= 12.

[buttons_proxy_ setMargin:gfx::Point(12, 11)];

}

if (title_bar_style_ == TitleBarStyle::kCustomButtonsOnHover) {

[buttons_proxy_ setShowOnHover:YES];

} else {

// customButtonsOnHover does not show buttons initially.

InternalSetWindowButtonVisibility(true);

}

}

}

// Create a tab only if tabbing identifier is specified and window has

// a native title bar.

if (tabbingIdentifier.empty() || transparent() || !has_frame()) {

if (@available(macOS 10.12, *)) {

[window_ setTabbingMode:NSWindowTabbingModeDisallowed];

}

} else {

if (@available(macOS 10.12, *)) {

[window_ setTabbingIdentifier:base::SysUTF8ToNSString(tabbingIdentifier)];

}

}

// Resize to content bounds.

bool use_content_size = false;

options.Get(options::kUseContentSize, &use_content_size);

if (!has_frame() || use_content_size)

SetContentSize(gfx::Size(width, height));

// Enable the NSView to accept first mouse event.

bool acceptsFirstMouse = false;

options.Get(options::kAcceptFirstMouse, &acceptsFirstMouse);

[window_ setAcceptsFirstMouse:acceptsFirstMouse];

// Disable auto-hiding cursor.

bool disableAutoHideCursor = false;

options.Get(options::kDisableAutoHideCursor, &disableAutoHideCursor);

[window_ setDisableAutoHideCursor:disableAutoHideCursor];

// Use an NSEvent monitor to listen for the wheel event.

BOOL __block began = NO;

wheel_event_monitor_ = [NSEvent

addLocalMonitorForEventsMatchingMask:NSEventMaskScrollWheel

handler:^(NSEvent* event) {

if ([[event window] windowNumber] !=

[window_ windowNumber])

return event;

if (!began && (([event phase] ==

NSEventPhaseMayBegin) ||

([event phase] ==

NSEventPhaseBegan))) {

this->NotifyWindowScrollTouchBegin();

began = YES;

} else if (began &&

(([event phase] ==

NSEventPhaseEnded) ||

([event phase] ==

NSEventPhaseCancelled))) {

this->NotifyWindowScrollTouchEnd();

began = NO;

}

return event;

}];

// Set maximizable state last to ensure zoom button does not get reset

// by calls to other APIs.

SetMaximizable(maximizable);

// Default content view.

SetContentView(new views::View());

AddContentViewLayers();

original_frame_ = [window_ frame];

original_level_ = [window_ level];

}

NativeWindowMac::~NativeWindowMac() = default;

void NativeWindowMac::SetContentView(views::View* view) {

views::View* root_view = GetContentsView();

if (content_view())

root_view->RemoveChildView(content_view());

set_content_view(view);

root_view->AddChildView(content_view());

root_view->Layout();

}

void NativeWindowMac::Close() {

if (!IsClosable()) {

WindowList::WindowCloseCancelled(this);

return;

}

// If a sheet is attached to the window when we call

// [window_ performClose:nil], the window won't close properly

// even after the user has ended the sheet.

// Ensure it's closed before calling [window_ performClose:nil].

SetEnabled(true);

[window_ performClose:nil];

// Closing a sheet doesn't trigger windowShouldClose,

// so we need to manually call it ourselves here.

if (is_modal() && parent() && IsVisible()) {

NotifyWindowCloseButtonClicked();

}

}

void NativeWindowMac::CloseImmediately() {

// Retain the child window before closing it. If the last reference to the

// NSWindow goes away inside -[NSWindow close], then bad stuff can happen.

// See e.g. http://crbug.com/616701.

base::scoped_nsobject<NSWindow> child_window(window_,

base::scoped_policy::RETAIN);

[window_ close];

}

void NativeWindowMac::Focus(bool focus) {

if (!IsVisible())

return;

if (focus) {

[[NSApplication sharedApplication] activateIgnoringOtherApps:NO];

[window_ makeKeyAndOrderFront:nil];

} else {

[window_ orderBack:nil];

}

}

bool NativeWindowMac::IsFocused() {

return [window_ isKeyWindow];

}

void NativeWindowMac::Show() {

if (is_modal() && parent()) {

NSWindow* window = parent()->GetNativeWindow().GetNativeNSWindow();

if ([window_ sheetParent] == nil)

[window beginSheet:window_

completionHandler:^(NSModalResponse){

}];

return;

}

// Reattach the window to the parent to actually show it.

if (parent())

InternalSetParentWindow(parent(), true);

// This method is supposed to put focus on window, however if the app does not

// have focus then "makeKeyAndOrderFront" will only show the window.

[NSApp activateIgnoringOtherApps:YES];

[window_ makeKeyAndOrderFront:nil];

}

void NativeWindowMac::ShowInactive() {

// Reattach the window to the parent to actually show it.

if (parent())

InternalSetParentWindow(parent(), true);

[window_ orderFrontRegardless];

}

void NativeWindowMac::Hide() {

// If a sheet is attached to the window when we call [window_ orderOut:nil],

// the sheet won't be able to show again on the same window.

// Ensure it's closed before calling [window_ orderOut:nil].

SetEnabled(true);

if (is_modal() && parent()) {

[window_ orderOut:nil];

[parent()->GetNativeWindow().GetNativeNSWindow() endSheet:window_];

return;

}

// Hide all children of the current window before hiding the window.

// components/remote_cocoa/app_shim/native_widget_ns_window_bridge.mm

// expects this when window visibility changes.

if ([window_ childWindows]) {

for (NSWindow* child in [window_ childWindows]) {

[child orderOut:nil];

}

}

// Detach the window from the parent before.

if (parent())

InternalSetParentWindow(parent(), false);

[window_ orderOut:nil];

}

bool NativeWindowMac::IsVisible() {

bool occluded = [window_ occlusionState] == NSWindowOcclusionStateVisible;

// For a window to be visible, it must be visible to the user in the

// foreground of the app, which means that it should not be minimized or

// occluded

return [window_ isVisible] && !occluded && !IsMinimized();

}

void NativeWindowMac::SetFullScreenTransitionState(

FullScreenTransitionState state) {

fullscreen_transition_state_ = state;

}

bool NativeWindowMac::IsEnabled() {

return [window_ attachedSheet] == nil;

}

void NativeWindowMac::SetEnabled(bool enable) {

if (!enable) {

[window_ beginSheet:window_

completionHandler:^(NSModalResponse returnCode) {

NSLog(@"modal enabled");

return;

}];

} else if ([window_ attachedSheet]) {

[window_ endSheet:[window_ attachedSheet]];

}

}

void NativeWindowMac::Maximize() {

const bool is_visible = [window_ isVisible];

if (IsMaximized()) {

if (!is_visible)

ShowInactive();

return;

}

// Take note of the current window size

if (IsNormal())

original_frame_ = [window_ frame];

[window_ zoom:nil];

if (!is_visible) {

ShowInactive();

NotifyWindowMaximize();

}

}

void NativeWindowMac::Unmaximize() {

// Bail if the last user set bounds were the same size as the window

// screen (e.g. the user set the window to maximized via setBounds)

//

// Per docs during zoom:

// > If there’s no saved user state because there has been no previous

// > zoom,the size and location of the window don’t change.

//

// However, in classic Apple fashion, this is not the case in practice,

// and the frame inexplicably becomes very tiny. We should prevent

// zoom from being called if the window is being unmaximized and its

// unmaximized window bounds are themselves functionally maximized.

if (!IsMaximized() || user_set_bounds_maximized_)

return;

[window_ zoom:nil];

}

bool NativeWindowMac::IsMaximized() {

if (([window_ styleMask] & NSWindowStyleMaskResizable) != 0)

return [window_ isZoomed];

NSRect rectScreen = GetAspectRatio() > 0.0

? default_frame_for_zoom()

: [[NSScreen mainScreen] visibleFrame];

return NSEqualRects([window_ frame], rectScreen);

}

void NativeWindowMac::Minimize() {

if (IsMinimized())

return;

// Take note of the current window size

if (IsNormal())

original_frame_ = [window_ frame];

[window_ miniaturize:nil];

}

void NativeWindowMac::Restore() {

[window_ deminiaturize:nil];

}

bool NativeWindowMac::IsMinimized() {

return [window_ isMiniaturized];

}

void NativeWindowMac::HandlePendingFullscreenTransitions() {

if (pending_transitions_.empty())

return;

bool next_transition = pending_transitions_.front();

pending_transitions_.pop();

SetFullScreen(next_transition);

}

void NativeWindowMac::SetFullScreen(bool fullscreen) {

// [NSWindow -toggleFullScreen] is an asynchronous operation, which means

// that it's possible to call it while a fullscreen transition is currently

// in process. This can create weird behavior (incl. phantom windows),

// so we want to schedule a transition for when the current one has completed.

if (fullscreen_transition_state() != FullScreenTransitionState::NONE) {

if (!pending_transitions_.empty()) {

bool last_pending = pending_transitions_.back();

// Only push new transitions if they're different than the last transition

// in the queue.

if (last_pending != fullscreen)

pending_transitions_.push(fullscreen);

} else {

pending_transitions_.push(fullscreen);

}

return;

}

if (fullscreen == IsFullscreen())

return;

// Take note of the current window size

if (IsNormal())

original_frame_ = [window_ frame];

// This needs to be set here because it can be the case that

// SetFullScreen is called by a user before windowWillEnterFullScreen

// or windowWillExitFullScreen are invoked, and so a potential transition

// could be dropped.

fullscreen_transition_state_ = fullscreen

? FullScreenTransitionState::ENTERING

: FullScreenTransitionState::EXITING;

[window_ toggleFullScreenMode:nil];

}

bool NativeWindowMac::IsFullscreen() const {

return [window_ styleMask] & NSWindowStyleMaskFullScreen;

}

void NativeWindowMac::SetBounds(const gfx::Rect& bounds, bool animate) {

// Do nothing if in fullscreen mode.

if (IsFullscreen())

return;

// Check size constraints since setFrame does not check it.

gfx::Size size = bounds.size();

size.SetToMax(GetMinimumSize());

gfx::Size max_size = GetMaximumSize();

if (!max_size.IsEmpty())

size.SetToMin(max_size);

NSRect cocoa_bounds = NSMakeRect(bounds.x(), 0, size.width(), size.height());

// Flip coordinates based on the primary screen.

NSScreen* screen = [[NSScreen screens] firstObject];

cocoa_bounds.origin.y = NSHeight([screen frame]) - size.height() - bounds.y();

[window_ setFrame:cocoa_bounds display:YES animate:animate];

user_set_bounds_maximized_ = IsMaximized() ? true : false;

}

gfx::Rect NativeWindowMac::GetBounds() {

NSRect frame = [window_ frame];

gfx::Rect bounds(frame.origin.x, 0, NSWidth(frame), NSHeight(frame));

NSScreen* screen = [[NSScreen screens] firstObject];

bounds.set_y(NSHeight([screen frame]) - NSMaxY(frame));

return bounds;

}

bool NativeWindowMac::IsNormal() {

return NativeWindow::IsNormal() && !IsSimpleFullScreen();

}

gfx::Rect NativeWindowMac::GetNormalBounds() {

if (IsNormal()) {

return GetBounds();

}

NSRect frame = original_frame_;

gfx::Rect bounds(frame.origin.x, 0, NSWidth(frame), NSHeight(frame));

NSScreen* screen = [[NSScreen screens] firstObject];

bounds.set_y(NSHeight([screen frame]) - NSMaxY(frame));

return bounds;

// Works on OS_WIN !

// return widget()->GetRestoredBounds();

}

void NativeWindowMac::SetContentSizeConstraints(

const extensions::SizeConstraints& size_constraints) {

auto convertSize = [this](const gfx::Size& size) {

// Our frameless window still has titlebar attached, so setting contentSize

// will result in actual content size being larger.

if (!has_frame()) {

NSRect frame = NSMakeRect(0, 0, size.width(), size.height());

NSRect content = [window_ originalContentRectForFrameRect:frame];

return content.size;

} else {

return NSMakeSize(size.width(), size.height());

}

};

NSView* content = [window_ contentView];

if (size_constraints.HasMinimumSize()) {

NSSize min_size = convertSize(size_constraints.GetMinimumSize());

[window_ setContentMinSize:[content convertSize:min_size toView:nil]];

}

if (size_constraints.HasMaximumSize()) {

NSSize max_size = convertSize(size_constraints.GetMaximumSize());

[window_ setContentMaxSize:[content convertSize:max_size toView:nil]];

}

NativeWindow::SetContentSizeConstraints(size_constraints);

}

bool NativeWindowMac::MoveAbove(const std::string& sourceId) {

const content::DesktopMediaID id = content::DesktopMediaID::Parse(sourceId);

if (id.type != content::DesktopMediaID::TYPE_WINDOW)

return false;

// Check if the window source is valid.

const CGWindowID window_id = id.id;

if (!webrtc::GetWindowOwnerPid(window_id))

return false;

[window_ orderWindow:NSWindowAbove relativeTo:id.id];

return true;

}

void NativeWindowMac::MoveTop() {

[window_ orderWindow:NSWindowAbove relativeTo:0];

}

void NativeWindowMac::SetResizable(bool resizable) {

SetStyleMask(resizable, NSWindowStyleMaskResizable);

SetCanResize(resizable);

}

bool NativeWindowMac::IsResizable() {

return [window_ styleMask] & NSWindowStyleMaskResizable;

}

void NativeWindowMac::SetMovable(bool movable) {

[window_ setMovable:movable];

}

bool NativeWindowMac::IsMovable() {

return [window_ isMovable];

}

void NativeWindowMac::SetMinimizable(bool minimizable) {

SetStyleMask(minimizable, NSMiniaturizableWindowMask);

}

bool NativeWindowMac::IsMinimizable() {

return [window_ styleMask] & NSMiniaturizableWindowMask;

}

void NativeWindowMac::SetMaximizable(bool maximizable) {

maximizable_ = maximizable;

[[window_ standardWindowButton:NSWindowZoomButton] setEnabled:maximizable];

}

bool NativeWindowMac::IsMaximizable() {

return [[window_ standardWindowButton:NSWindowZoomButton] isEnabled];

}

void NativeWindowMac::SetFullScreenable(bool fullscreenable) {

SetCollectionBehavior(fullscreenable,

NSWindowCollectionBehaviorFullScreenPrimary);

// On EL Capitan this flag is required to hide fullscreen button.

SetCollectionBehavior(!fullscreenable,

NSWindowCollectionBehaviorFullScreenAuxiliary);

}

bool NativeWindowMac::IsFullScreenable() {

NSUInteger collectionBehavior = [window_ collectionBehavior];

return collectionBehavior & NSWindowCollectionBehaviorFullScreenPrimary;

}

void NativeWindowMac::SetClosable(bool closable) {

SetStyleMask(closable, NSWindowStyleMaskClosable);

}

bool NativeWindowMac::IsClosable() {

return [window_ styleMask] & NSWindowStyleMaskClosable;

}

void NativeWindowMac::SetAlwaysOnTop(ui::ZOrderLevel z_order,

const std::string& level_name,

int relative_level) {

if (z_order == ui::ZOrderLevel::kNormal) {

SetWindowLevel(NSNormalWindowLevel);

return;

}

int level = NSNormalWindowLevel;

if (level_name == "floating") {

level = NSFloatingWindowLevel;

} else if (level_name == "torn-off-menu") {

level = NSTornOffMenuWindowLevel;

} else if (level_name == "modal-panel") {

level = NSModalPanelWindowLevel;

} else if (level_name == "main-menu") {

level = NSMainMenuWindowLevel;

} else if (level_name == "status") {

level = NSStatusWindowLevel;

} else if (level_name == "pop-up-menu") {

level = NSPopUpMenuWindowLevel;

} else if (level_name == "screen-saver") {

level = NSScreenSaverWindowLevel;

} else if (level_name == "dock") {

// Deprecated by macOS, but kept for backwards compatibility

level = NSDockWindowLevel;

}

SetWindowLevel(level + relative_level);

}

std::string NativeWindowMac::GetAlwaysOnTopLevel() {

std::string level_name = "normal";

int level = [window_ level];

if (level == NSFloatingWindowLevel) {

level_name = "floating";

} else if (level == NSTornOffMenuWindowLevel) {

level_name = "torn-off-menu";

} else if (level == NSModalPanelWindowLevel) {

level_name = "modal-panel";

} else if (level == NSMainMenuWindowLevel) {

level_name = "main-menu";

} else if (level == NSStatusWindowLevel) {

level_name = "status";

} else if (level == NSPopUpMenuWindowLevel) {

level_name = "pop-up-menu";

} else if (level == NSScreenSaverWindowLevel) {

level_name = "screen-saver";

} else if (level == NSDockWindowLevel) {

level_name = "dock";

}

return level_name;

}

void NativeWindowMac::SetWindowLevel(int unbounded_level) {

int level = std::min(

std::max(unbounded_level, CGWindowLevelForKey(kCGMinimumWindowLevelKey)),

CGWindowLevelForKey(kCGMaximumWindowLevelKey));

ui::ZOrderLevel z_order_level = level == NSNormalWindowLevel

? ui::ZOrderLevel::kNormal

: ui::ZOrderLevel::kFloatingWindow;

bool did_z_order_level_change = z_order_level != GetZOrderLevel();

was_maximizable_ = IsMaximizable();

// We need to explicitly keep the NativeWidget up to date, since it stores the

// window level in a local variable, rather than reading it from the NSWindow.

// Unfortunately, it results in a second setLevel call. It's not ideal, but we

// don't expect this to cause any user-visible jank.

widget()->SetZOrderLevel(z_order_level);

[window_ setLevel:level];

// Set level will make the zoom button revert to default, probably

// a bug of Cocoa or macOS.

SetMaximizable(was_maximizable_);

// This must be notified at the very end or IsAlwaysOnTop

// will not yet have been updated to reflect the new status

if (did_z_order_level_change)

NativeWindow::NotifyWindowAlwaysOnTopChanged();

}

ui::ZOrderLevel NativeWindowMac::GetZOrderLevel() {

return widget()->GetZOrderLevel();

}

void NativeWindowMac::Center() {

[window_ center];

}

void NativeWindowMac::Invalidate() {

[window_ flushWindow];

[[window_ contentView] setNeedsDisplay:YES];

}

void NativeWindowMac::SetTitle(const std::string& title) {

[window_ setTitle:base::SysUTF8ToNSString(title)];

if (buttons_proxy_)

[buttons_proxy_ redraw];

}

std::string NativeWindowMac::GetTitle() {

return base::SysNSStringToUTF8([window_ title]);

}

void NativeWindowMac::FlashFrame(bool flash) {

if (flash) {

attention_request_id_ = [NSApp requestUserAttention:NSInformationalRequest];

} else {

[NSApp cancelUserAttentionRequest:attention_request_id_];

attention_request_id_ = 0;

}

}

void NativeWindowMac::SetSkipTaskbar(bool skip) {}

bool NativeWindowMac::IsExcludedFromShownWindowsMenu() {

NSWindow* window = GetNativeWindow().GetNativeNSWindow();

return [window isExcludedFromWindowsMenu];

}

void NativeWindowMac::SetExcludedFromShownWindowsMenu(bool excluded) {

NSWindow* window = GetNativeWindow().GetNativeNSWindow();

[window setExcludedFromWindowsMenu:excluded];

}

void NativeWindowMac::OnDisplayMetricsChanged(const display::Display& display,

uint32_t changed_metrics) {

// We only want to force screen recalibration if we're in simpleFullscreen

// mode.

if (!is_simple_fullscreen_)

return;