wip

docs/README.md

@@ -107,7 +107,6 @@ These individual tutorials expand on topics discussed in the guide above.
 
 * [app](api/app.md)
 * [autoUpdater](api/auto-updater.md)
-* [BrowserView](api/browser-view.md)
 * [BrowserWindow](api/browser-window.md)
 * [contentTracing](api/content-tracing.md)
 * [dialog](api/dialog.md)

docs/api/base-window.md

@@ -0,0 +1,1446 @@
+# BaseWindow
+
+> Create and control windows.
+
+Process: [Main](../glossary.md#main-process)
+
+This module cannot be used until the `ready` event of the `app`
+module is emitted.
+
+```javascript
+// In the main process.
+const { BaseWindow } = require('electron')
+
+const win = new BaseWindow({ width: 800, height: 600 })
+
+// TODO example
+```
+
+## Parent and child windows
+
+By using `parent` option, you can create child windows:
+
+```javascript
+const { BaseWindow } = require('electron')
+
+const top = new BaseWindow()
+const child = new BaseWindow({ parent: top })
+```
+
+The `child` window will always show on top of the `top` window.
+
+## Modal windows
+
+A modal window is a child window that disables parent window, to create a modal
+window, you have to set both `parent` and `modal` options:
+
+```javascript
+const { BaseWindow } = require('electron')
+
+const top = new BaseWindow()
+const child = new BaseWindow({ parent: top, modal: true })
+```
+
+## Platform notices
+
+* On macOS modal windows will be displayed as sheets attached to the parent window.
+* On macOS the child windows will keep the relative position to parent window
+  when parent window moves, while on Windows and Linux child windows will not
+  move.
+* On Linux the type of modal windows will be changed to `dialog`.
+* On Linux many desktop environments do not support hiding a modal window.
+
+## Class: BaseWindow
+
+> Create and control windows.
+
+Process: [Main](../glossary.md#main-process)
+
+`BaseWindow` is an [EventEmitter][event-emitter].
+
+It creates a new `BaseWindow` with native properties as set by the `options`.
+
+### `new BaseWindow([options])`
+
+* `options` Object (optional)
+  * `width` Integer (optional) - Window's width in pixels. Default is `800`.
+  * `height` Integer (optional) - Window's height in pixels. Default is `600`.
+  * `x` Integer (optional) - (**required** if y is used) Window's left offset from screen.
+    Default is to center the window.
+  * `y` Integer (optional) - (**required** if x is used) Window's top offset from screen.
+    Default is to center the window.
+  * `useContentSize` boolean (optional) - The `width` and `height` would be
+    used as the content size, which means the actual window's size will include
+    window frame's size and be slightly larger. Default is `false`.
+  * `center` boolean (optional) - Show window in the center of the screen. Default is `false`.
+  * `minWidth` Integer (optional) - Window's minimum width. Default is `0`.
+  * `minHeight` Integer (optional) - Window's minimum height. Default is `0`.
+  * `maxWidth` Integer (optional) - Window's maximum width. Default is no limit.
+  * `maxHeight` Integer (optional) - Window's maximum height. Default is no limit.
+  * `resizable` boolean (optional) - Whether window is resizable. Default is `true`.
+  * `movable` boolean (optional) _macOS_ _Windows_ - Whether window is
+    movable. This is not implemented on Linux. Default is `true`.
+  * `minimizable` boolean (optional) _macOS_ _Windows_ - Whether window is
+    minimizable. This is not implemented on Linux. Default is `true`.
+  * `maximizable` boolean (optional) _macOS_ _Windows_ - Whether window is
+    maximizable. This is not implemented on Linux. Default is `true`.
+  * `closable` boolean (optional) _macOS_ _Windows_ - Whether window is
+    closable. This is not implemented on Linux. Default is `true`.
+  * `focusable` boolean (optional) - Whether the window can be focused. Default is
+    `true`. On Windows setting `focusable: false` also implies setting
+    `skipTaskbar: true`. On Linux setting `focusable: false` makes the window
+    stop interacting with wm, so the window will always stay on top in all
+    workspaces.
+  * `alwaysOnTop` boolean (optional) - Whether the window should always stay on top of
+    other windows. Default is `false`.
+  * `fullscreen` boolean (optional) - Whether the window should show in fullscreen. When
+    explicitly set to `false` the fullscreen button will be hidden or disabled
+    on macOS. Default is `false`.
+  * `fullscreenable` boolean (optional) - Whether the window can be put into fullscreen
+    mode. On macOS, also whether the maximize/zoom button should toggle full
+    screen mode or maximize window. Default is `true`.
+  * `simpleFullscreen` boolean (optional) _macOS_ - Use pre-Lion fullscreen on
+    macOS. Default is `false`.
+  * `skipTaskbar` boolean (optional) _macOS_ _Windows_ - Whether to show the window in taskbar.
+    Default is `false`.
+  * `kiosk` boolean (optional) - Whether the window is in kiosk mode. Default is `false`.
+  * `title` string (optional) - Window title. Default is `"Electron"`.
+  * `icon` ([NativeImage](native-image.md) | string) (optional) - The window icon. On Windows it is
+    recommended to use `ICO` icons to get best visual effects, you can also
+    leave it undefined so the executable's icon will be used.
+  * `show` boolean (optional) - Whether window should be shown when created. Default is
+    `true`.
+  * `frame` boolean (optional) - Specify `false` to create a
+    [frameless window](../tutorial/window-customization.md#create-frameless-windows). Default is `true`.
+  * `parent` BaseWindow (optional) - Specify parent window. Default is `null`.
+  * `modal` boolean (optional) - Whether this is a modal window. This only works when the
+    window is a child window. Default is `false`.
+  * `acceptFirstMouse` boolean (optional) _macOS_ - Whether clicking an
+    inactive window will also click through to the web contents. Default is
+    `false` on macOS. This option is not configurable on other platforms.
+  * `disableAutoHideCursor` boolean (optional) - Whether to hide cursor when typing.
+    Default is `false`.
+  * `autoHideMenuBar` boolean (optional) - Auto hide the menu bar unless the `Alt`
+    key is pressed. Default is `false`.
+  * `enableLargerThanScreen` boolean (optional) _macOS_ - Enable the window to
+    be resized larger than screen. Only relevant for macOS, as other OSes
+    allow larger-than-screen windows by default. Default is `false`.
+  * `backgroundColor` string (optional) - The window's background color in Hex, RGB, RGBA, HSL, HSLA or named CSS color format. Alpha in #AARRGGBB format is supported if `transparent` is set to `true`. Default is `#FFF` (white). See [win.setBackgroundColor](base-window.md#winsetbackgroundcolorbackgroundcolor) for more information.
+  * `hasShadow` boolean (optional) - Whether window should have a shadow. Default is `true`.
+  * `opacity` number (optional) _macOS_ _Windows_ - Set the initial opacity of
+    the window, between 0.0 (fully transparent) and 1.0 (fully opaque). This
+    is only implemented on Windows and macOS.
+  * `darkTheme` boolean (optional) - Forces using dark theme for the window, only works on
+    some GTK+3 desktop environments. Default is `false`.
+  * `transparent` boolean (optional) - Makes the window [transparent](../tutorial/window-customization.md#create-transparent-windows).
+    Default is `false`. On Windows, does not work unless the window is frameless.
+  * `type` string (optional) - The type of window, default is normal window. See more about
+    this below.
+  * `visualEffectState` string (optional) _macOS_ - Specify how the material
+    appearance should reflect window activity state on macOS. Must be used
+    with the `vibrancy` property. Possible values are:
+    * `followWindow` - The backdrop should automatically appear active when the window is active, and inactive when it is not. This is the default.
+    * `active` - The backdrop should always appear active.
+    * `inactive` - The backdrop should always appear inactive.
+  * `titleBarStyle` string (optional) _macOS_ _Windows_ - The style of window title bar.
+    Default is `default`. Possible values are:
+    * `default` - Results in the standard title bar for macOS or Windows respectively.
+    * `hidden` - Results in a hidden title bar and a full size content window. On macOS, the window still has the standard window controls (“traffic lights”) in the top left. On Windows, when combined with `titleBarOverlay: true` it will activate the Window Controls Overlay (see `titleBarOverlay` for more information), otherwise no window controls will be shown.
+    * `hiddenInset` _macOS_ - Only on macOS, results in a hidden title bar
+      with an alternative look where the traffic light buttons are slightly
+      more inset from the window edge.
+    * `customButtonsOnHover` _macOS_ - Only on macOS, results in a hidden
+      title bar and a full size content window, the traffic light buttons will
+      display when being hovered over in the top left of the window.
+      **Note:** This option is currently experimental.
+  * `trafficLightPosition` [Point](structures/point.md) (optional) _macOS_ -
+    Set a custom position for the traffic light buttons in frameless windows.
+  * `roundedCorners` boolean (optional) _macOS_ - Whether frameless window
+    should have rounded corners on macOS. Default is `true`. Setting this property
+    to `false` will prevent the window from being fullscreenable.
+  * `fullscreenWindowTitle` boolean (optional) _macOS_ _Deprecated_ - Shows
+    the title in the title bar in full screen mode on macOS for `hiddenInset`
+    titleBarStyle. Default is `false`.
+  * `thickFrame` boolean (optional) - Use `WS_THICKFRAME` style for frameless windows on
+    Windows, which adds standard window frame. Setting it to `false` will remove
+    window shadow and window animations. Default is `true`.
+  * `vibrancy` string (optional) _macOS_ - Add a type of vibrancy effect to
+    the window, only on macOS. Can be `appearance-based`, `light`, `dark`,
+    `titlebar`, `selection`, `menu`, `popover`, `sidebar`, `medium-light`,
+    `ultra-dark`, `header`, `sheet`, `window`, `hud`, `fullscreen-ui`,
+    `tooltip`, `content`, `under-window`, or `under-page`. Please note that
+    `appearance-based`, `light`, `dark`, `medium-light`, and `ultra-dark` are
+    deprecated and have been removed in macOS Catalina (10.15).
+  * `tabbingIdentifier` string (optional) _macOS_ - Tab group name, allows
+    opening the window as a native tab on macOS 10.12+. Windows with the same
+    tabbing identifier will be grouped together. This also adds a native new
+    tab button to your window's tab bar and allows your `app` and window to
+    receive the `new-window-for-tab` event.
+  * `titleBarOverlay` Object | Boolean (optional) -  When using a frameless window in conjunction with `win.setWindowButtonVisibility(true)` on macOS or using a `titleBarStyle` so that the standard window controls ("traffic lights" on macOS) are visible, this property enables the Window Controls Overlay [JavaScript APIs][overlay-javascript-apis] and [CSS Environment Variables][overlay-css-env-vars]. Specifying `true` will result in an overlay with default system colors. Default is `false`.
+    * `color` String (optional) _Windows_ - The CSS color of the Window Controls Overlay when enabled. Default is the system color.
+    * `symbolColor` String (optional) _Windows_ - The CSS color of the symbols on the Window Controls Overlay when enabled. Default is the system color.
+    * `height` Integer (optional) _macOS_ _Windows_ - The height of the title bar and Window Controls Overlay in pixels. Default is system height.
+
+When setting minimum or maximum window size with `minWidth`/`maxWidth`/
+`minHeight`/`maxHeight`, it only constrains the users. It won't prevent you from
+passing a size that does not follow size constraints to `setBounds`/`setSize` or
+to the constructor of `BaseWindow`.
+
+The possible values and behaviors of the `type` option are platform dependent.
+Possible values are:
+
+* On Linux, possible types are `desktop`, `dock`, `toolbar`, `splash`,
+  `notification`.
+* On macOS, possible types are `desktop`, `textured`, `panel`.
+  * The `textured` type adds metal gradient appearance
+    (`NSWindowStyleMaskTexturedBackground`).
+  * The `desktop` type places the window at the desktop background window level
+    (`kCGDesktopWindowLevel - 1`). Note that desktop window will not receive
+    focus, keyboard or mouse events, but you can use `globalShortcut` to receive
+    input sparingly.
+  * The `panel` type enables the window to float on top of full-screened apps
+    by adding the `NSWindowStyleMaskNonactivatingPanel` style mask,normally
+    reserved for NSPanel, at runtime. Also, the window will appear on all
+    spaces (desktops).
+* On Windows, possible type is `toolbar`.
+
+### Instance Events
+
+Objects created with `new BaseWindow` emit the following events:
+
+**Note:** Some events are only available on specific operating systems and are
+labeled as such.
+
+#### Event: 'close'
+
+Returns:
+
+* `event` Event
+
+Emitted when the window is going to be closed. It's emitted before the
+`beforeunload` and `unload` event of the DOM. Calling `event.preventDefault()`
+will cancel the close.
+
+Usually you would want to use the `beforeunload` handler to decide whether the
+window should be closed, which will also be called when the window is
+reloaded. In Electron, returning any value other than `undefined` would cancel the
+close. For example:
+
+```javascript
+window.onbeforeunload = (e) => {
+  console.log('I do not want to be closed')
+
+  // Unlike usual browsers that a message box will be prompted to users, returning
+  // a non-void value will silently cancel the close.
+  // It is recommended to use the dialog API to let the user confirm closing the
+  // application.
+  e.returnValue = false
+}
+```
+
+_**Note**: There is a subtle difference between the behaviors of `window.onbeforeunload = handler` and `window.addEventListener('beforeunload', handler)`. It is recommended to always set the `event.returnValue` explicitly, instead of only returning a value, as the former works more consistently within Electron._
+
+#### Event: 'closed'
+
+Emitted when the window is closed. After you have received this event you should
+remove the reference to the window and avoid using it any more.
+
+#### Event: 'session-end' _Windows_
+
+Emitted when window session is going to end due to force shutdown or machine restart
+or session log off.
+
+#### Event: 'blur'
+
+Emitted when the window loses focus.
+
+#### Event: 'focus'
+
+Emitted when the window gains focus.
+
+#### Event: 'show'
+
+Emitted when the window is shown.
+
+#### Event: 'hide'
+
+Emitted when the window is hidden.
+
+#### Event: 'maximize'
+
+Emitted when window is maximized.
+
+#### Event: 'unmaximize'
+
+Emitted when the window exits from a maximized state.
+
+#### Event: 'minimize'
+
+Emitted when the window is minimized.
+
+#### Event: 'restore'
+
+Emitted when the window is restored from a minimized state.
+
+#### Event: 'will-resize' _macOS_ _Windows_
+
+Returns:
+
+* `event` Event
+* `newBounds` [Rectangle](structures/rectangle.md) - Size the window is being resized to.
+* `details` Object
+  * `edge` (string) - The edge of the window being dragged for resizing. Can be `bottom`, `left`, `right`, `top-left`, `top-right`, `bottom-left` or `bottom-right`.
+
+Emitted before the window is resized. Calling `event.preventDefault()` will prevent the window from being resized.
+
+Note that this is only emitted when the window is being resized manually. Resizing the window with `setBounds`/`setSize` will not emit this event.
+
+The possible values and behaviors of the `edge` option are platform dependent. Possible values are:
+
+* On Windows, possible values are `bottom`, `top`, `left`, `right`, `top-left`, `top-right`, `bottom-left`, `bottom-right`.
+* On macOS, possible values are `bottom` and `right`.
+  * The value `bottom` is used to denote vertical resizing.
+  * The value `right` is used to denote horizontal resizing.
+
+#### Event: 'resize'
+
+Emitted after the window has been resized.
+
+#### Event: 'resized' _macOS_ _Windows_
+
+Emitted once when the window has finished being resized.
+
+This is usually emitted when the window has been resized manually. On macOS, resizing the window with `setBounds`/`setSize` and setting the `animate` parameter to `true` will also emit this event once resizing has finished.
+
+#### Event: 'will-move' _macOS_ _Windows_
+
+Returns:
+
+* `event` Event
+* `newBounds` [Rectangle](structures/rectangle.md) - Location the window is being moved to.
+
+Emitted before the window is moved. On Windows, calling `event.preventDefault()` will prevent the window from being moved.
+
+Note that this is only emitted when the window is being moved manually. Moving the window with `setPosition`/`setBounds`/`center` will not emit this event.
+
+#### Event: 'move'
+
+Emitted when the window is being moved to a new position.
+
+#### Event: 'moved' _macOS_ _Windows_
+
+Emitted once when the window is moved to a new position.
+
+__Note__: On macOS this event is an alias of `move`.
+
+#### Event: 'enter-full-screen'
+
+Emitted when the window enters a full-screen state.
+
+#### Event: 'leave-full-screen'
+
+Emitted when the window leaves a full-screen state.
+
+#### Event: 'always-on-top-changed'
+
+Returns:
+
+* `event` Event
+* `isAlwaysOnTop` boolean
+
+Emitted when the window is set or unset to show always on top of other windows.
+
+#### Event: 'app-command' _Windows_ _Linux_
+
+Returns:
+
+* `event` Event
+* `command` string
+
+Emitted when an [App Command](https://msdn.microsoft.com/en-us/library/windows/desktop/ms646275(v=vs.85).aspx)
+is invoked. These are typically related to keyboard media keys or browser
+commands, as well as the "Back" button built into some mice on Windows.
+
+Commands are lowercased, underscores are replaced with hyphens, and the
+`APPCOMMAND_` prefix is stripped off.
+e.g. `APPCOMMAND_BROWSER_BACKWARD` is emitted as `browser-backward`.
+
+```javascript
+const { BaseWindow } = require('electron')
+const win = new BaseWindow()
+win.on('app-command', (e, cmd) => {
+  // Navigate the window back when the user hits their mouse back button
+  if (cmd === 'browser-backward' && win.webContents.canGoBack()) {
+    win.webContents.goBack()
+  }
+})
+```
+
+The following app commands are explicitly supported on Linux:
+
+* `browser-backward`
+* `browser-forward`
+
+#### Event: 'swipe' _macOS_
+
+Returns:
+
+* `event` Event
+* `direction` string
+
+Emitted on 3-finger swipe. Possible directions are `up`, `right`, `down`, `left`.
+
+The method underlying this event is built to handle older macOS-style trackpad swiping,
+where the content on the screen doesn't move with the swipe. Most macOS trackpads are not
+configured to allow this kind of swiping anymore, so in order for it to emit properly the
+'Swipe between pages' preference in `System Preferences > Trackpad > More Gestures` must be
+set to 'Swipe with two or three fingers'.
+
+#### Event: 'rotate-gesture' _macOS_
+
+Returns:
+
+* `event` Event
+* `rotation` Float
+
+Emitted on trackpad rotation gesture. Continually emitted until rotation gesture is
+ended. The `rotation` value on each emission is the angle in degrees rotated since
+the last emission. The last emitted event upon a rotation gesture will always be of
+value `0`. Counter-clockwise rotation values are positive, while clockwise ones are
+negative.
+
+#### Event: 'sheet-begin' _macOS_
+
+Emitted when the window opens a sheet.
+
+#### Event: 'sheet-end' _macOS_
+
+Emitted when the window has closed a sheet.
+
+#### Event: 'new-window-for-tab' _macOS_
+
+Emitted when the native new tab button is clicked.
+
+#### Event: 'system-context-menu' _Windows_
+
+Returns:
+
+* `event` Event
+* `point` [Point](structures/point.md) - The screen coordinates the context menu was triggered at
+
+Emitted when the system context menu is triggered on the window, this is
+normally only triggered when the user right clicks on the non-client area
+of your window.  This is the window titlebar or any area you have declared
+as `-webkit-app-region: drag` in a frameless window.
+
+Calling `event.preventDefault()` will prevent the menu from being displayed.
+
+### Static Methods
+
+The `BaseWindow` class has the following static methods:
+
+#### `BaseWindow.getAllWindows()`
+
+Returns `BaseWindow[]` - An array of all opened windows.
+
+#### `BaseWindow.getFocusedWindow()`
+
+Returns `BaseWindow | null` - The window that is focused in this application, otherwise returns `null`.
+
+#### `BaseWindow.fromId(id)`
+
+* `id` Integer
+
+Returns `BaseWindow | null` - The window with the given `id`.
+
+### Instance Properties
+
+Objects created with `new BaseWindow` have the following properties:
+
+```javascript
+const { BaseWindow } = require('electron')
+// In this example `win` is our instance
+const win = new BaseWindow({ width: 800, height: 600 })
+```
+
+#### `win.id` _Readonly_
+
+A `Integer` property representing the unique ID of the window. Each ID is unique among all `BaseWindow` instances of the entire Electron application.
+
+#### `win.autoHideMenuBar`
+
+A `boolean` property that determines whether the window menu bar should hide itself automatically. Once set, the menu bar will only show when users press the single `Alt` key.
+
+If the menu bar is already visible, setting this property to `true` won't
+hide it immediately.
+
+#### `win.simpleFullScreen`
+
+A `boolean` property that determines whether the window is in simple (pre-Lion) fullscreen mode.
+
+#### `win.fullScreen`
+
+A `boolean` property that determines whether the window is in fullscreen mode.
+
+#### `win.focusable` _Windows_ _macOS_
+
+A `boolean` property that determines whether the window is focusable.
+
+#### `win.visibleOnAllWorkspaces` _macOS_ _Linux_
+
+A `boolean` property that determines whether the window is visible on all workspaces.
+
+**Note:** Always returns false on Windows.
+
+#### `win.shadow`
+
+A `boolean` property that determines whether the window has a shadow.
+
+#### `win.menuBarVisible` _Windows_ _Linux_
+
+A `boolean` property that determines whether the menu bar should be visible.
+
+**Note:** If the menu bar is auto-hide, users can still bring up the menu bar by pressing the single `Alt` key.
+
+#### `win.kiosk`
+
+A `boolean` property that determines whether the window is in kiosk mode.
+
+#### `win.documentEdited` _macOS_
+
+A `boolean` property that specifies whether the window’s document has been edited.
+
+The icon in title bar will become gray when set to `true`.
+
+#### `win.representedFilename` _macOS_
+
+A `string` property that determines the pathname of the file the window represents,
+and the icon of the file will show in window's title bar.
+
+#### `win.title`
+
+A `string` property that determines the title of the native window.
+
+**Note:** The title of the web page can be different from the title of the native window.
+
+#### `win.minimizable` _macOS_ _Windows_
+
+A `boolean` property that determines whether the window can be manually minimized by user.
+
+On Linux the setter is a no-op, although the getter returns `true`.
+
+#### `win.maximizable` _macOS_ _Windows_
+
+A `boolean` property that determines whether the window can be manually maximized by user.
+
+On Linux the setter is a no-op, although the getter returns `true`.
+
+#### `win.fullScreenable`
+
+A `boolean` property that determines whether the maximize/zoom window button toggles fullscreen mode or
+maximizes the window.
+
+#### `win.resizable`
+
+A `boolean` property that determines whether the window can be manually resized by user.
+
+#### `win.closable` _macOS_ _Windows_
+
+A `boolean` property that determines whether the window can be manually closed by user.
+
+On Linux the setter is a no-op, although the getter returns `true`.
+
+#### `win.movable` _macOS_ _Windows_
+
+A `boolean` property that determines Whether the window can be moved by user.
+
+On Linux the setter is a no-op, although the getter returns `true`.
+
+#### `win.excludedFromShownWindowsMenu` _macOS_
+
+A `boolean` property that determines whether the window is excluded from the application’s Windows menu. `false` by default.
+
+```js
+const win = new BaseWindow({ height: 600, width: 600 })
+
+const template = [
+  {
+    role: 'windowmenu'
+  }
+]
+
+win.excludedFromShownWindowsMenu = true
+
+const menu = Menu.buildFromTemplate(template)
+Menu.setApplicationMenu(menu)
+```
+
+#### `win.accessibleTitle`
+
+A `string` property that defines an alternative title provided only to
+accessibility tools such as screen readers. This string is not directly
+visible to users.
+
+### Instance Methods
+
+Objects created with `new BaseWindow` have the following instance methods:
+
+**Note:** Some methods are only available on specific operating systems and are
+labeled as such.
+
+#### `win.destroy()`
+
+Force closing the window, the `unload` and `beforeunload` event won't be emitted
+for the web page, and `close` event will also not be emitted
+for this window, but it guarantees the `closed` event will be emitted.
+
+#### `win.close()`
+
+Try to close the window. This has the same effect as a user manually clicking
+the close button of the window. The web page may cancel the close though. See
+the [close event](#event-close).
+
+#### `win.focus()`
+
+Focuses on the window.
+
+#### `win.blur()`
+
+Removes focus from the window.
+
+#### `win.isFocused()`
+
+Returns `boolean` - Whether the window is focused.
+
+#### `win.isDestroyed()`
+
+Returns `boolean` - Whether the window is destroyed.
+
+#### `win.show()`
+
+Shows and gives focus to the window.
+
+#### `win.showInactive()`
+
+Shows the window but doesn't focus on it.
+
+#### `win.hide()`
+
+Hides the window.
+
+#### `win.isVisible()`
+
+Returns `boolean` - Whether the window is visible to the user.
+
+#### `win.isModal()`
+
+Returns `boolean` - Whether current window is a modal window.
+
+#### `win.maximize()`
+
+Maximizes the window. This will also show (but not focus) the window if it
+isn't being displayed already.
+
+#### `win.unmaximize()`
+
+Unmaximizes the window.
+
+#### `win.isMaximized()`
+
+Returns `boolean` - Whether the window is maximized.
+
+#### `win.minimize()`
+
+Minimizes the window. On some platforms the minimized window will be shown in
+the Dock.
+
+#### `win.restore()`
+
+Restores the window from minimized state to its previous state.
+
+#### `win.isMinimized()`
+
+Returns `boolean` - Whether the window is minimized.
+
+#### `win.setFullScreen(flag)`
+
+* `flag` boolean
+
+Sets whether the window should be in fullscreen mode.
+
+#### `win.isFullScreen()`
+
+Returns `boolean` - Whether the window is in fullscreen mode.
+
+#### `win.setSimpleFullScreen(flag)` _macOS_
+
+* `flag` boolean
+
+Enters or leaves simple fullscreen mode.
+
+Simple fullscreen mode emulates the native fullscreen behavior found in versions of macOS prior to Lion (10.7).
+
+#### `win.isSimpleFullScreen()` _macOS_
+
+Returns `boolean` - Whether the window is in simple (pre-Lion) fullscreen mode.
+
+#### `win.isNormal()`
+
+Returns `boolean` - Whether the window is in normal state (not maximized, not minimized, not in fullscreen mode).
+
+#### `win.setAspectRatio(aspectRatio[, extraSize])`
+
+* `aspectRatio` Float - The aspect ratio to maintain for some portion of the
+content view.
+* `extraSize` [Size](structures/size.md) (optional) _macOS_ - The extra size not to be included while
+maintaining the aspect ratio.
+
+This will make a window maintain an aspect ratio. The extra size allows a
+developer to have space, specified in pixels, not included within the aspect
+ratio calculations. This API already takes into account the difference between a
+window's size and its content size.
+
+Consider a normal window with an HD video player and associated controls.
+Perhaps there are 15 pixels of controls on the left edge, 25 pixels of controls
+on the right edge and 50 pixels of controls below the player. In order to
+maintain a 16:9 aspect ratio (standard aspect ratio for HD @1920x1080) within
+the player itself we would call this function with arguments of 16/9 and
+{ width: 40, height: 50 }. The second argument doesn't care where the extra width and height
+are within the content view--only that they exist. Sum any extra width and
+height areas you have within the overall content view.
+
+The aspect ratio is not respected when window is resized programmatically with
+APIs like `win.setSize`.
+
+#### `win.setBackgroundColor(backgroundColor)`
+
+* `backgroundColor` string - Color in Hex, RGB, RGBA, HSL, HSLA or named CSS color format. The alpha channel is optional for the hex type.
+
+Examples of valid `backgroundColor` values:
+
+* Hex
+  * #fff (shorthand RGB)
+  * #ffff (shorthand ARGB)
+  * #ffffff (RGB)
+  * #ffffffff (ARGB)
+* RGB
+  * rgb\(([\d]+),\s*([\d]+),\s*([\d]+)\)
+    * e.g. rgb(255, 255, 255)
+* RGBA
+  * rgba\(([\d]+),\s*([\d]+),\s*([\d]+),\s*([\d.]+)\)
+    * e.g. rgba(255, 255, 255, 1.0)
+* HSL
+  * hsl\((-?[\d.]+),\s*([\d.]+)%,\s*([\d.]+)%\)
+    * e.g. hsl(200, 20%, 50%)
+* HSLA
+  * hsla\((-?[\d.]+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)
+    * e.g. hsla(200, 20%, 50%, 0.5)
+* Color name
+  * Options are listed in [SkParseColor.cpp](https://source.chromium.org/chromium/chromium/src/+/main:third_party/skia/src/utils/SkParseColor.cpp;l=11-152;drc=eea4bf52cb0d55e2a39c828b017c80a5ee054148)
+  * Similar to CSS Color Module Level 3 keywords, but case-sensitive.
+    * e.g. `blueviolet` or `red`
+
+Sets the background color of the window.
+
+#### `win.previewFile(path[, displayName])` _macOS_
+
+* `path` string - The absolute path to the file to preview with QuickLook. This
+  is important as Quick Look uses the file name and file extension on the path
+  to determine the content type of the file to open.
+* `displayName` string (optional) - The name of the file to display on the
+  Quick Look modal view. This is purely visual and does not affect the content
+  type of the file. Defaults to `path`.
+
+Uses [Quick Look][quick-look] to preview a file at a given path.
+
+#### `win.closeFilePreview()` _macOS_
+
+Closes the currently open [Quick Look][quick-look] panel.
+
+#### `win.setBounds(bounds[, animate])`
+
+* `bounds` Partial<[Rectangle](structures/rectangle.md)>
+* `animate` boolean (optional) _macOS_
+
+Resizes and moves the window to the supplied bounds. Any properties that are not supplied will default to their current values.
+
+```javascript
+const { BaseWindow } = require('electron')
+const win = new BaseWindow()
+
+// set all bounds properties
+win.setBounds({ x: 440, y: 225, width: 800, height: 600 })
+
+// set a single bounds property
+win.setBounds({ width: 100 })
+
+// { x: 440, y: 225, width: 100, height: 600 }
+console.log(win.getBounds())
+```
+
+#### `win.getBounds()`
+
+Returns [`Rectangle`](structures/rectangle.md) - The `bounds` of the window as `Object`.
+
+#### `win.getBackgroundColor()`
+
+Returns `string` - Gets the background color of the window in Hex (`#RRGGBB`) format.
+
+**Note:** The alpha value is _not_ returned alongside the red, green, and blue values.
+
+#### `win.setContentBounds(bounds[, animate])`
+
+* `bounds` [Rectangle](structures/rectangle.md)
+* `animate` boolean (optional) _macOS_
+
+Resizes and moves the window's client area (e.g. the web page) to
+the supplied bounds.
+
+#### `win.getContentBounds()`
+
+Returns [`Rectangle`](structures/rectangle.md) - The `bounds` of the window's client area as `Object`.
+
+#### `win.getNormalBounds()`
+
+Returns [`Rectangle`](structures/rectangle.md) - Contains the window bounds of the normal state
+
+**Note:** whatever the current state of the window : maximized, minimized or in fullscreen, this function always returns the position and size of the window in normal state. In normal state, getBounds and getNormalBounds returns the same [`Rectangle`](structures/rectangle.md).
+
+#### `win.setEnabled(enable)`
+
+* `enable` boolean
+
+Disable or enable the window.
+
+#### `win.isEnabled()`
+
+Returns `boolean` - whether the window is enabled.
+
+#### `win.setSize(width, height[, animate])`
+
+* `width` Integer
+* `height` Integer
+* `animate` boolean (optional) _macOS_
+
+Resizes the window to `width` and `height`. If `width` or `height` are below any set minimum size constraints the window will snap to its minimum size.
+
+#### `win.getSize()`
+
+Returns `Integer[]` - Contains the window's width and height.
+
+#### `win.setContentSize(width, height[, animate])`
+
+* `width` Integer
+* `height` Integer
+* `animate` boolean (optional) _macOS_
+
+Resizes the window's client area (e.g. the web page) to `width` and `height`.
+
+#### `win.getContentSize()`
+
+Returns `Integer[]` - Contains the window's client area's width and height.
+
+#### `win.setMinimumSize(width, height)`
+
+* `width` Integer
+* `height` Integer
+
+Sets the minimum size of window to `width` and `height`.
+
+#### `win.getMinimumSize()`
+
+Returns `Integer[]` - Contains the window's minimum width and height.
+
+#### `win.setMaximumSize(width, height)`
+
+* `width` Integer
+* `height` Integer
+
+Sets the maximum size of window to `width` and `height`.
+
+#### `win.getMaximumSize()`
+
+Returns `Integer[]` - Contains the window's maximum width and height.
+
+#### `win.setResizable(resizable)`
+
+* `resizable` boolean
+
+Sets whether the window can be manually resized by the user.
+
+#### `win.isResizable()`
+
+Returns `boolean` - Whether the window can be manually resized by the user.
+
+#### `win.setMovable(movable)` _macOS_ _Windows_
+
+* `movable` boolean
+
+Sets whether the window can be moved by user. On Linux does nothing.
+
+#### `win.isMovable()` _macOS_ _Windows_
+
+Returns `boolean` - Whether the window can be moved by user.
+
+On Linux always returns `true`.
+
+#### `win.setMinimizable(minimizable)` _macOS_ _Windows_
+
+* `minimizable` boolean
+
+Sets whether the window can be manually minimized by user. On Linux does nothing.
+
+#### `win.isMinimizable()` _macOS_ _Windows_
+
+Returns `boolean` - Whether the window can be manually minimized by the user.
+
+On Linux always returns `true`.
+
+#### `win.setMaximizable(maximizable)` _macOS_ _Windows_
+
+* `maximizable` boolean
+
+Sets whether the window can be manually maximized by user. On Linux does nothing.
+
+#### `win.isMaximizable()` _macOS_ _Windows_
+
+Returns `boolean` - Whether the window can be manually maximized by user.
+
+On Linux always returns `true`.
+
+#### `win.setFullScreenable(fullscreenable)`
+
+* `fullscreenable` boolean
+
+Sets whether the maximize/zoom window button toggles fullscreen mode or maximizes the window.
+
+#### `win.isFullScreenable()`
+
+Returns `boolean` - Whether the maximize/zoom window button toggles fullscreen mode or maximizes the window.
+
+#### `win.setClosable(closable)` _macOS_ _Windows_
+
+* `closable` boolean
+
+Sets whether the window can be manually closed by user. On Linux does nothing.
+
+#### `win.isClosable()` _macOS_ _Windows_
+
+Returns `boolean` - Whether the window can be manually closed by user.
+
+On Linux always returns `true`.
+
+#### `win.setAlwaysOnTop(flag[, level][, relativeLevel])`
+
+* `flag` boolean
+* `level` string (optional) _macOS_ _Windows_ - Values include `normal`,
+  `floating`, `torn-off-menu`, `modal-panel`, `main-menu`, `status`,
+  `pop-up-menu`, `screen-saver`, and ~~`dock`~~ (Deprecated). The default is
+  `floating` when `flag` is true. The `level` is reset to `normal` when the
+  flag is false. Note that from `floating` to `status` included, the window is
+  placed below the Dock on macOS and below the taskbar on Windows. From
+  `pop-up-menu` to a higher it is shown above the Dock on macOS and above the
+  taskbar on Windows. See the [macOS docs][window-levels] for more details.
+* `relativeLevel` Integer (optional) _macOS_ - The number of layers higher to set
+  this window relative to the given `level`. The default is `0`. Note that Apple
+  discourages setting levels higher than 1 above `screen-saver`.
+
+Sets whether the window should show always on top of other windows. After
+setting this, the window is still a normal window, not a toolbox window which
+can not be focused on.
+
+#### `win.isAlwaysOnTop()`
+
+Returns `boolean` - Whether the window is always on top of other windows.
+
+#### `win.moveAbove(mediaSourceId)`
+
+* `mediaSourceId` string - Window id in the format of DesktopCapturerSource's id. For example "window:1869:0".
+
+Moves window above the source window in the sense of z-order. If the
+`mediaSourceId` is not of type window or if the window does not exist then
+this method throws an error.
+
+#### `win.moveTop()`
+
+Moves window to top(z-order) regardless of focus
+
+#### `win.center()`
+
+Moves window to the center of the screen.
+
+#### `win.setPosition(x, y[, animate])`
+
+* `x` Integer
+* `y` Integer
+* `animate` boolean (optional) _macOS_
+
+Moves window to `x` and `y`.
+
+#### `win.getPosition()`
+
+Returns `Integer[]` - Contains the window's current position.
+
+#### `win.setTitle(title)`
+
+* `title` string
+
+Changes the title of native window to `title`.
+
+#### `win.getTitle()`
+
+Returns `string` - The title of the native window.
+
+**Note:** The title of the web page can be different from the title of the native
+window.
+
+#### `win.setSheetOffset(offsetY[, offsetX])` _macOS_
+
+* `offsetY` Float
+* `offsetX` Float (optional)
+
+Changes the attachment point for sheets on macOS. By default, sheets are
+attached just below the window frame.
+
+#### `win.flashFrame(flag)`
+
+* `flag` boolean
+
+Starts or stops flashing the window to attract user's attention.
+
+#### `win.setSkipTaskbar(skip)` _macOS_ _Windows_
+
+* `skip` boolean
+
+Makes the window not show in the taskbar.
+
+#### `win.setKiosk(flag)`
+
+* `flag` boolean
+
+Enters or leaves kiosk mode.
+
+#### `win.isKiosk()`
+
+Returns `boolean` - Whether the window is in kiosk mode.
+
+#### `win.isTabletMode()` _Windows_
+
+Returns `boolean` - Whether the window is in Windows 10 tablet mode.
+
+Since Windows 10 users can [use their PC as tablet](https://support.microsoft.com/en-us/help/17210/windows-10-use-your-pc-like-a-tablet),
+under this mode apps can choose to optimize their UI for tablets, such as
+enlarging the titlebar and hiding titlebar buttons.
+
+This API returns whether the window is in tablet mode, and the `resize` event
+can be be used to listen to changes to tablet mode.
+
+#### `win.getMediaSourceId()`
+
+Returns `string` - Window id in the format of DesktopCapturerSource's id. For example "window:1324:0".
+
+More precisely the format is `window:id:other_id` where `id` is `HWND` on
+Windows, `CGWindowID` (`uint64_t`) on macOS and `Window` (`unsigned long`) on
+Linux. `other_id` is used to identify web contents (tabs) so within the same
+top level window.
+
+#### `win.getNativeWindowHandle()`
+
+Returns `Buffer` - The platform-specific handle of the window.
+
+The native type of the handle is `HWND` on Windows, `NSView*` on macOS, and
+`Window` (`unsigned long`) on Linux.
+
+#### `win.hookWindowMessage(message, callback)` _Windows_
+
+* `message` Integer
+* `callback` Function
+  * `wParam` any - The `wParam` provided to the WndProc
+  * `lParam` any - The `lParam` provided to the WndProc
+
+Hooks a windows message. The `callback` is called when
+the message is received in the WndProc.
+
+#### `win.isWindowMessageHooked(message)` _Windows_
+
+* `message` Integer
+
+Returns `boolean` - `true` or `false` depending on whether the message is hooked.
+
+#### `win.unhookWindowMessage(message)` _Windows_
+
+* `message` Integer
+
+Unhook the window message.
+
+#### `win.unhookAllWindowMessages()` _Windows_
+
+Unhooks all of the window messages.
+
+#### `win.setRepresentedFilename(filename)` _macOS_
+
+* `filename` string
+
+Sets the pathname of the file the window represents, and the icon of the file
+will show in window's title bar.
+
+#### `win.getRepresentedFilename()` _macOS_
+
+Returns `string` - The pathname of the file the window represents.
+
+#### `win.setDocumentEdited(edited)` _macOS_
+
+* `edited` boolean
+
+Specifies whether the window’s document has been edited, and the icon in title
+bar will become gray when set to `true`.
+
+#### `win.isDocumentEdited()` _macOS_
+
+Returns `boolean` - Whether the window's document has been edited.
+
+#### `win.setMenu(menu)` _Linux_ _Windows_
+
+* `menu` Menu | null
+
+Sets the `menu` as the window's menu bar.
+
+#### `win.removeMenu()` _Linux_ _Windows_
+
+Remove the window's menu bar.
+
+#### `win.setProgressBar(progress[, options])`
+
+* `progress` Double
+* `options` Object (optional)
+  * `mode` string _Windows_ - Mode for the progress bar. Can be `none`, `normal`, `indeterminate`, `error` or `paused`.
+
+Sets progress value in progress bar. Valid range is [0, 1.0].
+
+Remove progress bar when progress < 0;
+Change to indeterminate mode when progress > 1.
+
+On Linux platform, only supports Unity desktop environment, you need to specify
+the `*.desktop` file name to `desktopName` field in `package.json`. By default,
+it will assume `{app.name}.desktop`.
+
+On Windows, a mode can be passed. Accepted values are `none`, `normal`,
+`indeterminate`, `error`, and `paused`. If you call `setProgressBar` without a
+mode set (but with a value within the valid range), `normal` will be assumed.
+
+#### `win.setOverlayIcon(overlay, description)` _Windows_
+
+* `overlay` [NativeImage](native-image.md) | null - the icon to display on the bottom
+right corner of the taskbar icon. If this parameter is `null`, the overlay is
+cleared
+* `description` string - a description that will be provided to Accessibility
+screen readers
+
+Sets a 16 x 16 pixel overlay onto the current taskbar icon, usually used to
+convey some sort of application status or to passively notify the user.
+
+#### `win.setHasShadow(hasShadow)`
+
+* `hasShadow` boolean
+
+Sets whether the window should have a shadow.
+
+#### `win.hasShadow()`
+
+Returns `boolean` - Whether the window has a shadow.
+
+#### `win.setOpacity(opacity)` _Windows_ _macOS_
+
+* `opacity` number - between 0.0 (fully transparent) and 1.0 (fully opaque)
+
+Sets the opacity of the window. On Linux, does nothing. Out of bound number
+values are clamped to the [0, 1] range.
+
+#### `win.getOpacity()`
+
+Returns `number` - between 0.0 (fully transparent) and 1.0 (fully opaque). On
+Linux, always returns 1.
+
+#### `win.setShape(rects)` _Windows_ _Linux_ _Experimental_
+
+* `rects` [Rectangle[]](structures/rectangle.md) - Sets a shape on the window.
+  Passing an empty list reverts the window to being rectangular.
+
+Setting a window shape determines the area within the window where the system
+permits drawing and user interaction. Outside of the given region, no pixels
+will be drawn and no mouse events will be registered. Mouse events outside of
+the region will not be received by that window, but will fall through to
+whatever is behind the window.
+
+#### `win.setThumbarButtons(buttons)` _Windows_
+
+* `buttons` [ThumbarButton[]](structures/thumbar-button.md)
+
+Returns `boolean` - Whether the buttons were added successfully
+
+Add a thumbnail toolbar with a specified set of buttons to the thumbnail image
+of a window in a taskbar button layout. Returns a `boolean` object indicates
+whether the thumbnail has been added successfully.
+
+The number of buttons in thumbnail toolbar should be no greater than 7 due to
+the limited room. Once you setup the thumbnail toolbar, the toolbar cannot be
+removed due to the platform's limitation. But you can call the API with an empty
+array to clean the buttons.
+
+The `buttons` is an array of `Button` objects:
+
+* `Button` Object
+  * `icon` [NativeImage](native-image.md) - The icon showing in thumbnail
+    toolbar.
+  * `click` Function
+  * `tooltip` string (optional) - The text of the button's tooltip.
+  * `flags` string[] (optional) - Control specific states and behaviors of the
+    button. By default, it is `['enabled']`.
+
+The `flags` is an array that can include following `string`s:
+
+* `enabled` - The button is active and available to the user.
+* `disabled` - The button is disabled. It is present, but has a visual state
+  indicating it will not respond to user action.
+* `dismissonclick` - When the button is clicked, the thumbnail window closes
+  immediately.
+* `nobackground` - Do not draw a button border, use only the image.
+* `hidden` - The button is not shown to the user.
+* `noninteractive` - The button is enabled but not interactive; no pressed
+  button state is drawn. This value is intended for instances where the button
+  is used in a notification.
+
+#### `win.setThumbnailClip(region)` _Windows_
+
+* `region` [Rectangle](structures/rectangle.md) - Region of the window
+
+Sets the region of the window to show as the thumbnail image displayed when
+hovering over the window in the taskbar. You can reset the thumbnail to be
+the entire window by specifying an empty region:
+`{ x: 0, y: 0, width: 0, height: 0 }`.
+
+#### `win.setThumbnailToolTip(toolTip)` _Windows_
+
+* `toolTip` string
+
+Sets the toolTip that is displayed when hovering over the window thumbnail
+in the taskbar.
+
+#### `win.setAppDetails(options)` _Windows_
+
+* `options` Object
+  * `appId` string (optional) - Window's [App User Model ID](https://msdn.microsoft.com/en-us/library/windows/desktop/dd391569(v=vs.85).aspx).
+    It has to be set, otherwise the other options will have no effect.
+  * `appIconPath` string (optional) - Window's [Relaunch Icon](https://msdn.microsoft.com/en-us/library/windows/desktop/dd391573(v=vs.85).aspx).
+  * `appIconIndex` Integer (optional) - Index of the icon in `appIconPath`.
+    Ignored when `appIconPath` is not set. Default is `0`.
+  * `relaunchCommand` string (optional) - Window's [Relaunch Command](https://msdn.microsoft.com/en-us/library/windows/desktop/dd391571(v=vs.85).aspx).
+  * `relaunchDisplayName` string (optional) - Window's [Relaunch Display Name](https://msdn.microsoft.com/en-us/library/windows/desktop/dd391572(v=vs.85).aspx).
+
+Sets the properties for the window's taskbar button.
+
+**Note:** `relaunchCommand` and `relaunchDisplayName` must always be set
+together. If one of those properties is not set, then neither will be used.
+
+#### `win.setIcon(icon)` _Windows_ _Linux_
+
+* `icon` [NativeImage](native-image.md) | string
+
+Changes window icon.
+
+#### `win.setWindowButtonVisibility(visible)` _macOS_
+
+* `visible` boolean
+
+Sets whether the window traffic light buttons should be visible.
+
+#### `win.setAutoHideMenuBar(hide)` _Windows_ _Linux_
+
+* `hide` boolean
+
+Sets whether the window menu bar should hide itself automatically. Once set the
+menu bar will only show when users press the single `Alt` key.
+
+If the menu bar is already visible, calling `setAutoHideMenuBar(true)` won't hide it immediately.
+
+#### `win.isMenuBarAutoHide()` _Windows_ _Linux_
+
+Returns `boolean` - Whether menu bar automatically hides itself.
+
+#### `win.setMenuBarVisibility(visible)` _Windows_ _Linux_
+
+* `visible` boolean
+
+Sets whether the menu bar should be visible. If the menu bar is auto-hide, users can still bring up the menu bar by pressing the single `Alt` key.
+
+#### `win.isMenuBarVisible()` _Windows_ _Linux_
+
+Returns `boolean` - Whether the menu bar is visible.
+
+#### `win.setVisibleOnAllWorkspaces(visible[, options])` _macOS_ _Linux_
+
+* `visible` boolean
+* `options` Object (optional)
+  * `visibleOnFullScreen` boolean (optional) _macOS_ - Sets whether
+    the window should be visible above fullscreen windows.
+  * `skipTransformProcessType` boolean (optional) _macOS_ - Calling
+    setVisibleOnAllWorkspaces will by default transform the process
+    type between UIElementApplication and ForegroundApplication to
+    ensure the correct behavior. However, this will hide the window
+    and dock for a short time every time it is called. If your window
+    is already of type UIElementApplication, you can bypass this
+    transformation by passing true to skipTransformProcessType.
+
+Sets whether the window should be visible on all workspaces.
+
+**Note:** This API does nothing on Windows.
+
+#### `win.isVisibleOnAllWorkspaces()` _macOS_ _Linux_
+
+Returns `boolean` - Whether the window is visible on all workspaces.
+
+**Note:** This API always returns false on Windows.
+
+#### `win.setIgnoreMouseEvents(ignore[, options])`
+
+* `ignore` boolean
+* `options` Object (optional)
+  * `forward` boolean (optional) _macOS_ _Windows_ - If true, forwards mouse move
+    messages to Chromium, enabling mouse related events such as `mouseleave`.
+    Only used when `ignore` is true. If `ignore` is false, forwarding is always
+    disabled regardless of this value.
+
+Makes the window ignore all mouse events.
+
+All mouse events happened in this window will be passed to the window below
+this window, but if this window has focus, it will still receive keyboard
+events.
+
+#### `win.setContentProtection(enable)` _macOS_ _Windows_
+
+* `enable` boolean
+
+Prevents the window contents from being captured by other apps.
+
+On macOS it sets the NSWindow's sharingType to NSWindowSharingNone.
+On Windows it calls SetWindowDisplayAffinity with `WDA_EXCLUDEFROMCAPTURE`.
+For Windows 10 version 2004 and up the window will be removed from capture entirely,
+older Windows versions behave as if `WDA_MONITOR` is applied capturing a black window.
+
+#### `win.setFocusable(focusable)` _macOS_ _Windows_
+
+* `focusable` boolean
+
+Changes whether the window can be focused.
+
+On macOS it does not remove the focus from the window.
+
+#### `win.isFocusable()` _macOS_ _Windows_
+
+Returns whether the window can be focused.
+
+#### `win.setParentWindow(parent)`
+
+* `parent` BaseWindow | null
+
+Sets `parent` as current window's parent window, passing `null` will turn
+current window into a top-level window.
+
+#### `win.getParentWindow()`
+
+Returns `BaseWindow | null` - The parent window or `null` if there is no parent.
+
+#### `win.getChildWindows()`
+
+Returns `BaseWindow[]` - All child windows.
+
+#### `win.setAutoHideCursor(autoHide)` _macOS_
+
+* `autoHide` boolean
+
+Controls whether to hide cursor when typing.
+
+#### `win.selectPreviousTab()` _macOS_
+
+Selects the previous tab when native tabs are enabled and there are other
+tabs in the window.
+
+#### `win.selectNextTab()` _macOS_
+
+Selects the next tab when native tabs are enabled and there are other
+tabs in the window.
+
+#### `win.mergeAllWindows()` _macOS_
+
+Merges all windows into one window with multiple tabs when native tabs
+are enabled and there is more than one open window.
+
+#### `win.moveTabToNewWindow()` _macOS_
+
+Moves the current tab into a new window if native tabs are enabled and
+there is more than one tab in the current window.
+
+#### `win.toggleTabBar()` _macOS_
+
+Toggles the visibility of the tab bar if native tabs are enabled and
+there is only one tab in the current window.
+
+#### `win.addTabbedWindow(baseWindow)` _macOS_
+
+* `baseWindow` BaseWindow
+
+Adds a window as a tab on this window, after the tab for the window instance.
+
+#### `win.setVibrancy(type)` _macOS_
+
+* `type` string | null - Can be `appearance-based`, `light`, `dark`, `titlebar`,
+  `selection`, `menu`, `popover`, `sidebar`, `medium-light`, `ultra-dark`, `header`, `sheet`, `window`, `hud`, `fullscreen-ui`, `tooltip`, `content`, `under-window`, or `under-page`. See
+  the [macOS documentation][vibrancy-docs] for more details.
+
+Adds a vibrancy effect to the window. Passing `null` or an empty string
+will remove the vibrancy effect on the window.
+
+Note that `appearance-based`, `light`, `dark`, `medium-light`, and `ultra-dark` have been
+deprecated and will be removed in an upcoming version of macOS.
+
+#### `win.setTrafficLightPosition(position)` _macOS_
+
+* `position` [Point](structures/point.md)
+
+Set a custom position for the traffic light buttons in frameless window.
+
+#### `win.getTrafficLightPosition()` _macOS_
+
+Returns `Point` - The custom position for the traffic light buttons in
+frameless window.
+
+#### `win.setTouchBar(touchBar)` _macOS_
+
+* `touchBar` TouchBar | null
+
+Sets the touchBar layout for the current window. Specifying `null` or
+`undefined` clears the touch bar. This method only has an effect if the
+machine has a touch bar and is running on macOS 10.12.1+.
+
+**Note:** The TouchBar API is currently experimental and may change or be
+removed in future Electron releases.
+
+#### `win.setTitleBarOverlay(options)` _Windows_
+
+* `options` Object
+  * `color` String (optional) _Windows_ - The CSS color of the Window Controls Overlay when enabled.
+  * `symbolColor` String (optional) _Windows_ - The CSS color of the symbols on the Window Controls Overlay when enabled.
+  * `height` Integer (optional) _Windows_ - The height of the title bar and Window Controls Overlay in pixels.
+
+On a Window with Window Controls Overlay already enabled, this method updates
+the style of the title bar overlay.
+
+[runtime-enabled-features]: https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/runtime_enabled_features.json5?l=70
+[page-visibility-api]: https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API
+[quick-look]: https://en.wikipedia.org/wiki/Quick_Look
+[vibrancy-docs]: https://developer.apple.com/documentation/appkit/nsvisualeffectview?preferredLanguage=objc
+[window-levels]: https://developer.apple.com/documentation/appkit/nswindow/level
+[chrome-content-scripts]: https://developer.chrome.com/extensions/content_scripts#execution-environment
+[event-emitter]: https://nodejs.org/api/events.html#events_class_eventemitter
+[overlay-javascript-apis]: https://github.com/WICG/window-controls-overlay/blob/main/explainer.md#javascript-apis
+[overlay-css-env-vars]: https://github.com/WICG/window-controls-overlay/blob/main/explainer.md#css-environment-variables

docs/api/browser-view.md

@@ -1,103 +0,0 @@
-# BrowserView
-
-A `BrowserView` can be used to embed additional web content into a
-[`BrowserWindow`](browser-window.md). It is like a child window, except that it is positioned
-relative to its owning window. It is meant to be an alternative to the
-`webview` tag.
-
-## Class: BrowserView
-
-> Create and control views.
-
-Process: [Main](../glossary.md#main-process)
-
-This module cannot be used until the `ready` event of the `app`
-module is emitted.
-
-### Example
-
-```javascript
-// In the main process.
-const { app, BrowserView, BrowserWindow } = require('electron')
-
-app.whenReady().then(() => {
-  const win = new BrowserWindow({ width: 800, height: 600 })
-
-  const view = new BrowserView()
-  win.setBrowserView(view)
-  view.setBounds({ x: 0, y: 0, width: 300, height: 300 })
-  view.webContents.loadURL('https://electronjs.org')
-})
-```
-
-### `new BrowserView([options])` _Experimental_
-
-* `options` Object (optional)
-  * `webPreferences` Object (optional) - See [BrowserWindow](browser-window.md).
-
-### Instance Properties
-
-Objects created with `new BrowserView` have the following properties:
-
-#### `view.webContents` _Experimental_
-
-A [`WebContents`](web-contents.md) object owned by this view.
-
-### Instance Methods
-
-Objects created with `new BrowserView` have the following instance methods:
-
-#### `view.setAutoResize(options)` _Experimental_
-
-* `options` Object
-  * `width` boolean (optional) - If `true`, the view's width will grow and shrink together
-    with the window. `false` by default.
-  * `height` boolean (optional) - If `true`, the view's height will grow and shrink
-    together with the window. `false` by default.
-  * `horizontal` boolean (optional) - If `true`, the view's x position and width will grow
-    and shrink proportionally with the window. `false` by default.
-  * `vertical` boolean (optional) - If `true`, the view's y position and height will grow
-    and shrink proportionally with the window. `false` by default.
-
-#### `view.setBounds(bounds)` _Experimental_
-
-* `bounds` [Rectangle](structures/rectangle.md)
-
-Resizes and moves the view to the supplied bounds relative to the window.
-
-#### `view.getBounds()` _Experimental_
-
-Returns [`Rectangle`](structures/rectangle.md)
-
-The `bounds` of this BrowserView instance as `Object`.
-
-#### `view.setBackgroundColor(color)` _Experimental_
-
-* `color` string - Color in Hex, RGB, ARGB, HSL, HSLA or named CSS color format. The alpha channel is
-  optional for the hex type.
-
-Examples of valid `color` values:
-
-* Hex
-  * #fff (RGB)
-  * #ffff (ARGB)
-  * #ffffff (RRGGBB)
-  * #ffffffff (AARRGGBB)
-* RGB
-  * rgb\(([\d]+),\s*([\d]+),\s*([\d]+)\)
-    * e.g. rgb(255, 255, 255)
-* RGBA
-  * rgba\(([\d]+),\s*([\d]+),\s*([\d]+),\s*([\d.]+)\)
-    * e.g. rgba(255, 255, 255, 1.0)
-* HSL
-  * hsl\((-?[\d.]+),\s*([\d.]+)%,\s*([\d.]+)%\)
-    * e.g. hsl(200, 20%, 50%)
-* HSLA
-  * hsla\((-?[\d.]+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)
-    * e.g. hsla(200, 20%, 50%, 0.5)
-* Color name
-  * Options are listed in [SkParseColor.cpp](https://source.chromium.org/chromium/chromium/src/+/main:third_party/skia/src/utils/SkParseColor.cpp;l=11-152;drc=eea4bf52cb0d55e2a39c828b017c80a5ee054148)
-  * Similar to CSS Color Module Level 3 keywords, but case-sensitive.
-    * e.g. `blueviolet` or `red`
-
-**Note:** Hex format with alpha takes `AARRGGBB` or `ARGB`, _not_ `RRGGBBA` or `RGA`.

docs/api/browser-window.md

@@ -139,7 +139,7 @@ state is `hidden` in order to minimize power consumption.
 * On Linux the type of modal windows will be changed to `dialog`.
 * On Linux many desktop environments do not support hiding a modal window.
 
-## Class: BrowserWindow
+## Class: BrowserWindow extends `BaseWindow`
 
 > Create and control browser windows.
 
@@ -737,12 +737,6 @@ Returns `BrowserWindow | null` - The window that is focused in this application,
 Returns `BrowserWindow | null` - The window that owns the given `webContents`
 or `null` if the contents are not owned by a window.
 
-#### `BrowserWindow.fromBrowserView(browserView)`
-
-* `browserView` [BrowserView](browser-view.md)
-
-Returns `BrowserWindow | null` - The window that owns the given `browserView`. If the given view is not attached to any window, returns `null`.
-
 #### `BrowserWindow.fromId(id)`
 
 * `id` Integer
@@ -1823,42 +1817,6 @@ machine has a touch bar and is running on macOS 10.12.1+.
 **Note:** The TouchBar API is currently experimental and may change or be
 removed in future Electron releases.
 
-#### `win.setBrowserView(browserView)` _Experimental_
-
-* `browserView` [BrowserView](browser-view.md) | null - Attach `browserView` to `win`.
-If there are other `BrowserView`s attached, they will be removed from
-this window.
-
-#### `win.getBrowserView()` _Experimental_
-
-Returns `BrowserView | null` - The `BrowserView` attached to `win`. Returns `null`
-if one is not attached. Throws an error if multiple `BrowserView`s are attached.
-
-#### `win.addBrowserView(browserView)` _Experimental_
-
-* `browserView` [BrowserView](browser-view.md)
-
-Replacement API for setBrowserView supporting work with multi browser views.
-
-#### `win.removeBrowserView(browserView)` _Experimental_
-
-* `browserView` [BrowserView](browser-view.md)
-
-#### `win.setTopBrowserView(browserView)` _Experimental_
-
-* `browserView` [BrowserView](browser-view.md)
-
-Raises `browserView` above other `BrowserView`s attached to `win`.
-Throws an error if `browserView` is not attached to `win`.
-
-#### `win.getBrowserViews()` _Experimental_
-
-Returns `BrowserView[]` - an array of all BrowserViews that have been attached
-with `addBrowserView` or `setBrowserView`.
-
-**Note:** The BrowserView API is currently experimental and may change or be
-removed in future Electron releases.
-
 #### `win.setTitleBarOverlay(options)` _Windows_
 
 * `options` Object

docs/api/environment-variables.md

@@ -132,11 +132,6 @@ Setting this variable is the same as passing `--log-file`
 on the command line. For more info, see `--log-file` in [command-line
 switches](./command-line-switches.md#--log-filepath).
 
-### `ELECTRON_DEBUG_DRAG_REGIONS`
-
-Adds coloration to draggable regions on [`BrowserView`](./browser-view.md)s on macOS - draggable regions will be colored
-green and non-draggable regions will be colored red to aid debugging.
-
 ### `ELECTRON_DEBUG_NOTIFICATIONS`
 
 Adds extra logs to [`Notification`](./notification.md) lifecycles on macOS to aid in debugging. Extra logging will be displayed when new Notifications are created or activated. They will also be displayed when common actions are taken: a notification is shown, dismissed, its button is clicked, or it is replied to.

docs/api/view.md

@@ -0,0 +1,32 @@
+# View
+
+> A View.
+
+Process: [Main](../glossary.md#main-process)
+
+This module cannot be used until the `ready` event of the `app`
+module is emitted.
+
+```javascript
+// TODO example
+```
+
+## Class: View
+
+> A View.
+
+Process: [Main](../glossary.md#main-process)
+
+`View` is an [EventEmitter][event-emitter].
+
+### `new View()`
+
+Creates a new `View`.
+
+### Instance Methods
+
+Objects created with `new View` have the following instance methods:
+
+#### `view.addChildView(view)`
+
+* `view` View - child view to add.

docs/api/web-contents-view.md

@@ -0,0 +1,38 @@
+# WebContentsView
+
+> A View that displays a WebContents.
+
+Process: [Main](../glossary.md#main-process)
+
+This module cannot be used until the `ready` event of the `app`
+module is emitted.
+
+```javascript
+// TODO example
+```
+
+## Class: WebContentsView extends `View`
+
+> A View that displays a WebContents.
+
+Process: [Main](../glossary.md#main-process)
+
+`WebContentsView` is an [EventEmitter][event-emitter].
+
+### `new WebContentsView([options])`
+
+* `options` WebPreferences (optional) - See ... (TODO)
+
+### Instance Properties
+
+Objects created with `new WebContentsView` have the following properties:
+
+```javascript
+const { WebContentsView } = require('electron')
+// In this example `win` is our instance
+const win = new WebContentsView()
+```
+
+#### `win.webContents` _Readonly_
+
+A `WebContents` property containing a reference to the displayed `WebContents`.

docs/api/webview-tag.md

@@ -5,8 +5,8 @@
 Electron's `webview` tag is based on [Chromium's `webview`][chrome-webview], which
 is undergoing dramatic architectural changes. This impacts the stability of `webviews`,
 including rendering, navigation, and event routing. We currently recommend to not
-use the `webview` tag and to consider alternatives, like `iframe`, [Electron's `BrowserView`](browser-view.md),
-or an architecture that avoids embedded content altogether.
+use the `webview` tag and to consider alternatives, like `iframe` or an
+architecture that avoids embedded content altogether.
 
 ## Enabling
 

docs/tutorial/security.md

@@ -79,8 +79,8 @@ will be able to execute native code on the user's machine.
 Under no circumstances should you load and execute remote code with
 Node.js integration enabled. Instead, use only local files (packaged together
 with your application) to execute Node.js code. To display remote content, use
-the [`<webview>`][webview-tag] tag or [`BrowserView`][browser-view], make sure
-to disable the `nodeIntegration` and enable `contextIsolation`.
+the [`<webview>`][webview-tag] tag and make sure to disable the
+`nodeIntegration` and enable `contextIsolation`.
 :::
 
 :::info Electron security warnings
@@ -167,11 +167,10 @@ This recommendation is the default behavior in Electron since 5.0.0.
 :::
 
 It is paramount that you do not enable Node.js integration in any renderer
-([`BrowserWindow`][browser-window], [`BrowserView`][browser-view], or
-[`<webview>`][webview-tag]) that loads remote content. The goal is to limit the
-powers you grant to remote content, thus making it dramatically more difficult
-for an attacker to harm your users should they gain the ability to execute
-JavaScript on your website.
+([`BrowserWindow`][browser-window] or [`<webview>`][webview-tag]) that loads
+remote content. The goal is to limit the powers you grant to remote content,
+thus making it dramatically more difficult for an attacker to harm your users
+should they gain the ability to execute JavaScript on your website.
 
 After this, you can grant additional permissions for specific hosts. For example,
 if you are opening a BrowserWindow pointed at `https://example.com/`, you can
@@ -306,9 +305,8 @@ This recommendation is Electron's default.
 :::
 
 You may have already guessed that disabling the `webSecurity` property on a
-renderer process ([`BrowserWindow`][browser-window],
-[`BrowserView`][browser-view], or [`<webview>`][webview-tag]) disables crucial
-security features.
+renderer process ([`BrowserWindow`][browser-window], or
+[`<webview>`][webview-tag]) disables crucial security features.
 
 Do not disable `webSecurity` in production applications.
 
@@ -761,7 +759,6 @@ function validateSender(frame) {
 
 [breaking-changes]: ../breaking-changes.md
 [browser-window]: ../api/browser-window.md
-[browser-view]: ../api/browser-view.md
 [webview-tag]: ../api/webview-tag.md
 [web-contents]: ../api/web-contents.md
 [window-open-handler]: ../api/web-contents.md#contentssetwindowopenhandlerhandler

docs/tutorial/web-embeds.md

@@ -41,17 +41,3 @@ communication with the `<webview>` is done asynchronously using IPC. The
 Compared to an `<iframe>`, `<webview>` tends to be slightly slower but offers
 much greater control in loading and communicating with the third-party content
 and handling various events.
-
-### BrowserViews
-
-[BrowserViews](../api/browser-view.md) are not a part of the DOM - instead,
-they are created in and controlled by your Main process. They are simply
-another layer of web content on top of your existing window. This means
-that they are completely separate from your own `BrowserWindow` content and
-their position is not controlled by the DOM or CSS. Instead, it is controlled
-by setting the bounds in the Main process.
-
-`BrowserViews` offer the greatest control over their contents, since they
-implement the `webContents` similarly to how the `BrowserWindow` does it.
-However, as `BrowserViews` are not a part of your DOM, but are rather overlaid
-on top of them, you will have to manage their position manually.

filenames.auto.gni

@@ -4,7 +4,7 @@ auto_filenames = {
     "docs/api/accelerator.md",
     "docs/api/app.md",
     "docs/api/auto-updater.md",
-    "docs/api/browser-view.md",
+    "docs/api/base-window.md",
     "docs/api/browser-window.md",
     "docs/api/client-request.md",
     "docs/api/clipboard.md",
@@ -62,6 +62,8 @@ auto_filenames = {
     "docs/api/touch-bar-spacer.md",
     "docs/api/touch-bar.md",
     "docs/api/tray.md",
+    "docs/api/view.md",
+    "docs/api/web-contents-view.md",
     "docs/api/web-contents.md",
     "docs/api/web-frame-main.md",
     "docs/api/web-frame.md",
@@ -188,7 +190,6 @@ auto_filenames = {
     "lib/browser/api/auto-updater/auto-updater-win.ts",
     "lib/browser/api/auto-updater/squirrel-update-win.ts",
     "lib/browser/api/base-window.ts",
-    "lib/browser/api/browser-view.ts",
     "lib/browser/api/browser-window.ts",
     "lib/browser/api/content-tracing.ts",
     "lib/browser/api/crash-reporter.ts",

filenames.gni

@@ -147,8 +147,6 @@ filenames = {
     "shell/browser/mac/in_app_purchase_product.mm",
     "shell/browser/mac/in_app_purchase.h",
     "shell/browser/mac/in_app_purchase.mm",
-    "shell/browser/native_browser_view_mac.h",
-    "shell/browser/native_browser_view_mac.mm",
     "shell/browser/native_window_mac.h",
     "shell/browser/native_window_mac.mm",
     "shell/browser/notifications/mac/cocoa_notification.h",
@@ -214,8 +212,6 @@ filenames = {
     "shell/browser/api/electron_api_browser_window_views.cc",
     "shell/browser/api/electron_api_menu_views.cc",
     "shell/browser/api/electron_api_menu_views.h",
-    "shell/browser/native_browser_view_views.cc",
-    "shell/browser/native_browser_view_views.h",
     "shell/browser/native_window_views.cc",
     "shell/browser/native_window_views.h",
     "shell/browser/ui/drag_util_views.cc",
@@ -258,8 +254,6 @@ filenames = {
     "shell/browser/api/electron_api_auto_updater.h",
     "shell/browser/api/electron_api_base_window.cc",
     "shell/browser/api/electron_api_base_window.h",
-    "shell/browser/api/electron_api_browser_view.cc",
-    "shell/browser/api/electron_api_browser_view.h",
     "shell/browser/api/electron_api_browser_window.cc",
     "shell/browser/api/electron_api_browser_window.h",
     "shell/browser/api/electron_api_content_tracing.cc",
@@ -418,8 +412,6 @@ filenames = {
     "shell/browser/media/media_device_id_salt.h",
     "shell/browser/microtasks_runner.cc",
     "shell/browser/microtasks_runner.h",
-    "shell/browser/native_browser_view.cc",
-    "shell/browser/native_browser_view.h",
     "shell/browser/native_window.cc",
     "shell/browser/native_window.h",
     "shell/browser/native_window_features.cc",

lib/browser/api/base-window.ts

@@ -4,7 +4,7 @@ const { BaseWindow } = process._linkedBinding('electron_browser_base_window') as
 
 Object.setPrototypeOf(BaseWindow.prototype, EventEmitter.prototype);
 
-BaseWindow.prototype._init = function () {
+BaseWindow.prototype._init = function (this: TLWT) {
   // Avoid recursive require.
   const { app } = require('electron');
 
@@ -103,7 +103,7 @@ Object.defineProperty(BaseWindow.prototype, 'movable', {
 });
 
 BaseWindow.getFocusedWindow = () => {
-  return BaseWindow.getAllWindows().find((win) => win.isFocused());
+  return BaseWindow.getAllWindows().find((win) => win.isFocused()) ?? null;
 };
 
 module.exports = BaseWindow;

lib/browser/api/browser-view.ts

@@ -1,3 +0,0 @@
-const { BrowserView } = process._linkedBinding('electron_browser_browser_view');
-
-export default BrowserView;

lib/browser/api/browser-window.ts

@@ -1,4 +1,4 @@
-import { BaseWindow, WebContents, Event, BrowserView, TouchBar } from 'electron/main';
+import { BaseWindow, WebContents, Event, TouchBar } from 'electron/main';
 import type { BrowserWindow as BWT } from 'electron/main';
 const { BrowserWindow } = process._linkedBinding('electron_browser_window') as { BrowserWindow: typeof BWT };
 
@@ -6,7 +6,7 @@ Object.setPrototypeOf(BrowserWindow.prototype, BaseWindow.prototype);
 
 BrowserWindow.prototype._init = function (this: BWT) {
   // Call parent class's _init.
-  BaseWindow.prototype._init.call(this);
+  (BaseWindow.prototype as any)._init.call(this);
 
   // Avoid recursive require.
   const { app } = require('electron');
@@ -28,6 +28,34 @@ BrowserWindow.prototype._init = function (this: BWT) {
     app.emit('browser-window-focus', event, this);
   });
 
+  let unresponsiveEvent: any = null;
+  const emitUnresponsiveEvent = () => {
+    unresponsiveEvent = null;
+    if (!this.isDestroyed() && this.isEnabled()) { this.emit('unresponsive'); }
+  };
+  this.webContents.on('unresponsive', () => {
+    if (!unresponsiveEvent) { unresponsiveEvent = setTimeout(emitUnresponsiveEvent, 50); }
+  });
+  this.webContents.on('responsive', () => {
+    if (unresponsiveEvent) {
+      clearTimeout(unresponsiveEvent);
+      unresponsiveEvent = null;
+    }
+    this.emit('responsive');
+  });
+  this.on('close', (e) => {
+    e.preventDefault();
+    if (!this.webContents || this.webContents.isDestroyed()) return;
+
+    if (!unresponsiveEvent) { unresponsiveEvent = setTimeout(emitUnresponsiveEvent, 5000); }
+
+    this.webContents.close({ waitForBeforeUnload: true });
+  });
+  this.webContents.on('destroyed', () => {
+    clearTimeout(unresponsiveEvent);
+    unresponsiveEvent = null;
+  });
+
   // Subscribe to visibilityState changes and pass to renderer process.
   let isVisible = this.isVisible() && !this.isMinimized();
   const visibilityChanged = () => {
@@ -83,10 +111,6 @@ BrowserWindow.fromWebContents = (webContents: WebContents) => {
   return webContents.getOwnerBrowserWindow();
 };
 
-BrowserWindow.fromBrowserView = (browserView: BrowserView) => {
-  return BrowserWindow.fromWebContents(browserView.webContents);
-};
-
 BrowserWindow.prototype.setTouchBar = function (touchBar) {
   (TouchBar as any)._setOnWindow(touchBar, this);
 };

lib/browser/api/module-list.ts

@@ -5,7 +5,6 @@ export const browserModuleList: ElectronInternal.ModuleEntry[] = [
   { name: 'app', loader: () => require('./app') },
   { name: 'autoUpdater', loader: () => require('./auto-updater') },
   { name: 'BaseWindow', loader: () => require('./base-window') },
-  { name: 'BrowserView', loader: () => require('./browser-view') },
   { name: 'BrowserWindow', loader: () => require('./browser-window') },
   { name: 'contentTracing', loader: () => require('./content-tracing') },
   { name: 'crashReporter', loader: () => require('./crash-reporter') },

shell/browser/api/electron_api_base_window.cc

@@ -10,7 +10,6 @@
 
 #include "electron/buildflags/buildflags.h"
 #include "gin/dictionary.h"
-#include "shell/browser/api/electron_api_browser_view.h"
 #include "shell/browser/api/electron_api_menu.h"
 #include "shell/browser/api/electron_api_view.h"
 #include "shell/browser/api/electron_api_web_contents.h"
@@ -161,7 +160,6 @@ void BaseWindow::OnWindowClosed() {
   Emit("closed");
 
   RemoveFromParentChildWindows();
-  BaseWindow::ResetBrowserViews();
 
   // Destroy the native class when window is closed.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, GetDestroyClosure());
@@ -315,7 +313,6 @@ void BaseWindow::OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) {
 #endif
 
 void BaseWindow::SetContentView(gin::Handle<View> view) {
-  ResetBrowserViews();
   content_view_.Reset(isolate(), view.ToV8());
   window_->SetContentView(view->view());
 }
@@ -753,54 +750,6 @@ void BaseWindow::SetParentWindow(v8::Local<v8::Value> value,
   }
 }
 
-void BaseWindow::SetBrowserView(
-    absl::optional<gin::Handle<BrowserView>> browser_view) {
-  ResetBrowserViews();
-  if (browser_view)
-    AddBrowserView(*browser_view);
-}
-
-void BaseWindow::AddBrowserView(gin::Handle<BrowserView> browser_view) {
-  auto iter = browser_views_.find(browser_view->ID());
-  if (iter == browser_views_.end()) {
-    // If we're reparenting a BrowserView, ensure that it's detached from
-    // its previous owner window.
-    BaseWindow* owner_window = browser_view->owner_window();
-    if (owner_window) {
-      // iter == browser_views_.end() should imply owner_window != this.
-      DCHECK_NE(owner_window, this);
-      owner_window->RemoveBrowserView(browser_view);
-      browser_view->SetOwnerWindow(nullptr);
-    }
-
-    window_->AddBrowserView(browser_view->view());
-    browser_view->SetOwnerWindow(this);
-    browser_views_[browser_view->ID()].Reset(isolate(), browser_view.ToV8());
-  }
-}
-
-void BaseWindow::RemoveBrowserView(gin::Handle<BrowserView> browser_view) {
-  auto iter = browser_views_.find(browser_view->ID());
-  if (iter != browser_views_.end()) {
-    window_->RemoveBrowserView(browser_view->view());
-    browser_view->SetOwnerWindow(nullptr);
-    iter->second.Reset();
-    browser_views_.erase(iter);
-  }
-}
-
-void BaseWindow::SetTopBrowserView(gin::Handle<BrowserView> browser_view,
-                                   gin_helper::Arguments* args) {
-  BaseWindow* owner_window = browser_view->owner_window();
-  auto iter = browser_views_.find(browser_view->ID());
-  if (iter == browser_views_.end() || (owner_window && owner_window != this)) {
-    args->ThrowError("Given BrowserView is not attached to the window");
-    return;
-  }
-
-  window_->SetTopBrowserView(browser_view->view());
-}
-
 std::string BaseWindow::GetMediaSourceId() const {
   return window_->GetDesktopMediaID().ToString();
 }
@@ -985,31 +934,6 @@ std::vector<v8::Local<v8::Object>> BaseWindow::GetChildWindows() const {
   return child_windows_.Values(isolate());
 }
 
-v8::Local<v8::Value> BaseWindow::GetBrowserView(
-    gin_helper::Arguments* args) const {
-  if (browser_views_.empty()) {
-    return v8::Null(isolate());
-  } else if (browser_views_.size() == 1) {
-    auto first_view = browser_views_.begin();
-    return v8::Local<v8::Value>::New(isolate(), (*first_view).second);
-  } else {
-    args->ThrowError(
-        "BrowserWindow have multiple BrowserViews, "
-        "Use getBrowserViews() instead");
-    return v8::Null(isolate());
-  }
-}
-
-std::vector<v8::Local<v8::Value>> BaseWindow::GetBrowserViews() const {
-  std::vector<v8::Local<v8::Value>> ret;
-
-  for (auto const& views_iter : browser_views_) {
-    ret.push_back(v8::Local<v8::Value>::New(isolate(), views_iter.second));
-  }
-
-  return ret;
-}
-
 bool BaseWindow::IsModal() const {
   return window_->is_modal();
 }
@@ -1107,30 +1031,6 @@ int32_t BaseWindow::GetID() const {
   return weak_map_id();
 }
 
-void BaseWindow::ResetBrowserViews() {
-  v8::HandleScope scope(isolate());
-
-  for (auto& item : browser_views_) {
-    gin::Handle<BrowserView> browser_view;
-    if (gin::ConvertFromV8(isolate(),
-                           v8::Local<v8::Value>::New(isolate(), item.second),
-                           &browser_view) &&
-        !browser_view.IsEmpty()) {
-      // There's a chance that the BrowserView may have been reparented - only
-      // reset if the owner window is *this* window.
-      BaseWindow* owner_window = browser_view->owner_window();
-      DCHECK_EQ(owner_window, this);
-      browser_view->SetOwnerWindow(nullptr);
-      window_->RemoveBrowserView(browser_view->view());
-      browser_view->SetOwnerWindow(nullptr);
-    }
-
-    item.second.Reset();
-  }
-
-  browser_views_.clear();
-}
-
 void BaseWindow::RemoveFromParentChildWindows() {
   if (parent_window_.IsEmpty())
     return;
@@ -1241,10 +1141,6 @@ void BaseWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setMenu", &BaseWindow::SetMenu)
       .SetMethod("removeMenu", &BaseWindow::RemoveMenu)
       .SetMethod("setParentWindow", &BaseWindow::SetParentWindow)
-      .SetMethod("setBrowserView", &BaseWindow::SetBrowserView)
-      .SetMethod("addBrowserView", &BaseWindow::AddBrowserView)
-      .SetMethod("removeBrowserView", &BaseWindow::RemoveBrowserView)
-      .SetMethod("setTopBrowserView", &BaseWindow::SetTopBrowserView)
       .SetMethod("getMediaSourceId", &BaseWindow::GetMediaSourceId)
       .SetMethod("getNativeWindowHandle", &BaseWindow::GetNativeWindowHandle)
       .SetMethod("setProgressBar", &BaseWindow::SetProgressBar)
@@ -1292,8 +1188,6 @@ void BaseWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getContentView", &BaseWindow::GetContentView)
       .SetMethod("getParentWindow", &BaseWindow::GetParentWindow)
       .SetMethod("getChildWindows", &BaseWindow::GetChildWindows)
-      .SetMethod("getBrowserView", &BaseWindow::GetBrowserView)
-      .SetMethod("getBrowserViews", &BaseWindow::GetBrowserViews)
       .SetMethod("isModal", &BaseWindow::IsModal)
       .SetMethod("setThumbarButtons", &BaseWindow::SetThumbarButtons)
 #if defined(TOOLKIT_VIEWS)

shell/browser/api/electron_api_base_window.h

@@ -22,7 +22,6 @@
 namespace electron::api {
 
 class View;
-class BrowserView;
 
 class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
                    public NativeWindowObserver {
@@ -174,14 +173,6 @@ class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
   void SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> menu);
   void RemoveMenu();
   void SetParentWindow(v8::Local<v8::Value> value, gin_helper::Arguments* args);
-  virtual void SetBrowserView(
-      absl::optional<gin::Handle<BrowserView>> browser_view);
-  virtual void AddBrowserView(gin::Handle<BrowserView> browser_view);
-  virtual void RemoveBrowserView(gin::Handle<BrowserView> browser_view);
-  virtual void SetTopBrowserView(gin::Handle<BrowserView> browser_view,
-                                 gin_helper::Arguments* args);
-  virtual std::vector<v8::Local<v8::Value>> GetBrowserViews() const;
-  virtual void ResetBrowserViews();
   std::string GetMediaSourceId() const;
   v8::Local<v8::Value> GetNativeWindowHandle();
   void SetProgressBar(double progress, gin_helper::Arguments* args);
@@ -222,7 +213,6 @@ class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
   v8::Local<v8::Value> GetContentView() const;
   v8::Local<v8::Value> GetParentWindow() const;
   std::vector<v8::Local<v8::Object>> GetChildWindows() const;
-  v8::Local<v8::Value> GetBrowserView(gin_helper::Arguments* args) const;
   bool IsModal() const;
 
   // Extra APIs added in JS.
@@ -249,9 +239,6 @@ class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
 
   // Helpers.
 
-  // Remove BrowserView.
-  void ResetBrowserView();
-
   // Remove this window from parent window's |child_windows_|.
   void RemoveFromParentChildWindows();
 
@@ -269,7 +256,6 @@ class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
 #endif
 
   v8::Global<v8::Value> content_view_;
-  std::map<int32_t, v8::Global<v8::Value>> browser_views_;
   v8::Global<v8::Value> menu_;
   v8::Global<v8::Value> parent_window_;
   KeyWeakMap<int> child_windows_;

shell/browser/api/electron_api_browser_view.cc

@@ -1,220 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "shell/browser/api/electron_api_browser_view.h"
-
-#include <vector>
-
-#include "content/browser/renderer_host/render_widget_host_view_base.h"  // nogncheck
-#include "content/public/browser/render_widget_host_view.h"
-#include "shell/browser/api/electron_api_base_window.h"
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/native_browser_view.h"
-#include "shell/browser/ui/drag_util.h"
-#include "shell/browser/web_contents_preferences.h"
-#include "shell/common/color_util.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
-#include "ui/gfx/geometry/rect.h"
-
-namespace gin {
-
-template <>
-struct Converter<electron::AutoResizeFlags> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     electron::AutoResizeFlags* auto_resize_flags) {
-    gin_helper::Dictionary params;
-    if (!ConvertFromV8(isolate, val, &params)) {
-      return false;
-    }
-
-    uint8_t flags = 0;
-    bool width = false;
-    if (params.Get("width", &width) && width) {
-      flags |= electron::kAutoResizeWidth;
-    }
-    bool height = false;
-    if (params.Get("height", &height) && height) {
-      flags |= electron::kAutoResizeHeight;
-    }
-    bool horizontal = false;
-    if (params.Get("horizontal", &horizontal) && horizontal) {
-      flags |= electron::kAutoResizeHorizontal;
-    }
-    bool vertical = false;
-    if (params.Get("vertical", &vertical) && vertical) {
-      flags |= electron::kAutoResizeVertical;
-    }
-
-    *auto_resize_flags = static_cast<electron::AutoResizeFlags>(flags);
-    return true;
-  }
-};
-
-}  // namespace gin
-
-namespace {
-
-int32_t GetNextId() {
-  static int32_t next_id = 1;
-  return next_id++;
-}
-
-}  // namespace
-
-namespace electron::api {
-
-gin::WrapperInfo BrowserView::kWrapperInfo = {gin::kEmbedderNativeGin};
-
-BrowserView::BrowserView(gin::Arguments* args,
-                         const gin_helper::Dictionary& options)
-    : id_(GetNextId()) {
-  v8::Isolate* isolate = args->isolate();
-  gin_helper::Dictionary web_preferences =
-      gin::Dictionary::CreateEmpty(isolate);
-  options.Get(options::kWebPreferences, &web_preferences);
-  web_preferences.Set("type", "browserView");
-
-  v8::Local<v8::Value> value;
-
-  // Copy the webContents option to webPreferences.
-  if (options.Get("webContents", &value)) {
-    web_preferences.SetHidden("webContents", value);
-  }
-
-  auto web_contents =
-      WebContents::CreateFromWebPreferences(args->isolate(), web_preferences);
-
-  web_contents_.Reset(isolate, web_contents.ToV8());
-  api_web_contents_ = web_contents.get();
-  api_web_contents_->AddObserver(this);
-  Observe(web_contents->web_contents());
-
-  view_.reset(
-      NativeBrowserView::Create(api_web_contents_->inspectable_web_contents()));
-}
-
-void BrowserView::SetOwnerWindow(BaseWindow* window) {
-  // Ensure WebContents and BrowserView owner windows are in sync.
-  if (web_contents())
-    web_contents()->SetOwnerWindow(window ? window->window() : nullptr);
-
-  owner_window_ = window ? window->GetWeakPtr() : nullptr;
-}
-
-BrowserView::~BrowserView() {
-  if (web_contents()) {  // destroy() called without closing WebContents
-    web_contents()->RemoveObserver(this);
-    web_contents()->Destroy();
-  }
-}
-
-void BrowserView::WebContentsDestroyed() {
-  api_web_contents_ = nullptr;
-  web_contents_.Reset();
-  Unpin();
-}
-
-void BrowserView::OnDraggableRegionsUpdated(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
-  view_->UpdateDraggableRegions(regions);
-}
-
-// static
-gin::Handle<BrowserView> BrowserView::New(gin_helper::ErrorThrower thrower,
-                                          gin::Arguments* args) {
-  if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError("Cannot create BrowserView before app is ready");
-    return gin::Handle<BrowserView>();
-  }
-
-  gin::Dictionary options = gin::Dictionary::CreateEmpty(args->isolate());
-  args->GetNext(&options);
-
-  auto handle =
-      gin::CreateHandle(args->isolate(), new BrowserView(args, options));
-  handle->Pin(args->isolate());
-  return handle;
-}
-
-void BrowserView::SetAutoResize(AutoResizeFlags flags) {
-  view_->SetAutoResizeFlags(flags);
-}
-
-void BrowserView::SetBounds(const gfx::Rect& bounds) {
-  view_->SetBounds(bounds);
-}
-
-gfx::Rect BrowserView::GetBounds() {
-  return view_->GetBounds();
-}
-
-void BrowserView::SetBackgroundColor(const std::string& color_name) {
-  SkColor color = ParseCSSColor(color_name);
-  view_->SetBackgroundColor(color);
-
-  if (web_contents()) {
-    auto* wc = web_contents()->web_contents();
-    wc->SetPageBaseBackgroundColor(ParseCSSColor(color_name));
-
-    auto* const rwhv = wc->GetRenderWidgetHostView();
-    if (rwhv) {
-      rwhv->SetBackgroundColor(color);
-      static_cast<content::RenderWidgetHostViewBase*>(rwhv)
-          ->SetContentBackgroundColor(color);
-    }
-
-    // Ensure new color is stored in webPreferences, otherwise
-    // the color will be reset on the next load via HandleNewRenderFrame.
-    auto* web_preferences = WebContentsPreferences::From(wc);
-    if (web_preferences)
-      web_preferences->SetBackgroundColor(color);
-  }
-}
-
-v8::Local<v8::Value> BrowserView::GetWebContents(v8::Isolate* isolate) {
-  if (web_contents_.IsEmpty()) {
-    return v8::Null(isolate);
-  }
-
-  return v8::Local<v8::Value>::New(isolate, web_contents_);
-}
-
-// static
-v8::Local<v8::ObjectTemplate> BrowserView::FillObjectTemplate(
-    v8::Isolate* isolate,
-    v8::Local<v8::ObjectTemplate> templ) {
-  return gin::ObjectTemplateBuilder(isolate, "BrowserView", templ)
-      .SetMethod("setAutoResize", &BrowserView::SetAutoResize)
-      .SetMethod("setBounds", &BrowserView::SetBounds)
-      .SetMethod("getBounds", &BrowserView::GetBounds)
-      .SetMethod("setBackgroundColor", &BrowserView::SetBackgroundColor)
-      .SetProperty("webContents", &BrowserView::GetWebContents)
-      .Build();
-}
-
-}  // namespace electron::api
-
-namespace {
-
-using electron::api::BrowserView;
-
-void Initialize(v8::Local<v8::Object> exports,
-                v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context,
-                void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-
-  gin_helper::Dictionary dict(isolate, exports);
-  dict.Set("BrowserView", BrowserView::GetConstructor(context));
-}
-
-}  // namespace
-
-NODE_LINKED_MODULE_CONTEXT_AWARE(electron_browser_browser_view, Initialize)

shell/browser/api/electron_api_browser_view.h

@@ -1,94 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_
-#define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "content/public/browser/web_contents_observer.h"
-#include "gin/handle.h"
-#include "gin/wrappable.h"
-#include "shell/browser/extended_web_contents_observer.h"
-#include "shell/browser/native_browser_view.h"
-#include "shell/browser/native_window.h"
-#include "shell/common/api/api.mojom.h"
-#include "shell/common/gin_helper/constructible.h"
-#include "shell/common/gin_helper/error_thrower.h"
-#include "shell/common/gin_helper/pinnable.h"
-
-namespace gfx {
-class Rect;
-}
-
-namespace gin_helper {
-class Dictionary;
-}
-
-namespace electron::api {
-
-class WebContents;
-class BaseWindow;
-
-class BrowserView : public gin::Wrappable<BrowserView>,
-                    public gin_helper::Constructible<BrowserView>,
-                    public gin_helper::Pinnable<BrowserView>,
-                    public content::WebContentsObserver,
-                    public ExtendedWebContentsObserver {
- public:
-  // gin_helper::Constructible
-  static gin::Handle<BrowserView> New(gin_helper::ErrorThrower thrower,
-                                      gin::Arguments* args);
-  static v8::Local<v8::ObjectTemplate> FillObjectTemplate(
-      v8::Isolate*,
-      v8::Local<v8::ObjectTemplate>);
-
-  // gin::Wrappable
-  static gin::WrapperInfo kWrapperInfo;
-
-  WebContents* web_contents() const { return api_web_contents_; }
-  NativeBrowserView* view() const { return view_.get(); }
-
-  BaseWindow* owner_window() const { return owner_window_.get(); }
-
-  void SetOwnerWindow(BaseWindow* window);
-
-  int32_t ID() const { return id_; }
-
-  // disable copy
-  BrowserView(const BrowserView&) = delete;
-  BrowserView& operator=(const BrowserView&) = delete;
-
- protected:
-  BrowserView(gin::Arguments* args, const gin_helper::Dictionary& options);
-  ~BrowserView() override;
-
-  // content::WebContentsObserver:
-  void WebContentsDestroyed() override;
-
-  // ExtendedWebContentsObserver:
-  void OnDraggableRegionsUpdated(
-      const std::vector<mojom::DraggableRegionPtr>& regions) override;
-
- private:
-  void SetAutoResize(AutoResizeFlags flags);
-  void SetBounds(const gfx::Rect& bounds);
-  gfx::Rect GetBounds();
-  void SetBackgroundColor(const std::string& color_name);
-  v8::Local<v8::Value> GetWebContents(v8::Isolate*);
-
-  v8::Global<v8::Value> web_contents_;
-  class WebContents* api_web_contents_ = nullptr;
-
-  std::unique_ptr<NativeBrowserView> view_;
-  base::WeakPtr<BaseWindow> owner_window_;
-
-  int32_t id_;
-};
-
-}  // namespace electron::api
-
-#endif  // ELECTRON_SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_

shell/browser/api/electron_api_browser_window.cc

@@ -13,7 +13,6 @@
 #include "content/public/common/color_parser.h"
 #include "shell/browser/api/electron_api_web_contents_view.h"
 #include "shell/browser/browser.h"
-#include "shell/browser/native_browser_view.h"
 #include "shell/browser/web_contents_preferences.h"
 #include "shell/browser/window_list.h"
 #include "shell/common/color_util.h"
@@ -133,7 +132,7 @@ BrowserWindow::~BrowserWindow() {
       host->GetWidget()->RemoveInputEventObserver(this);
     api_web_contents_->RemoveObserver(this);
     // Destroy the WebContents.
-    OnCloseContents();
+    api_web_contents_->Destroy();
   }
 }
 
@@ -179,11 +178,6 @@ void BrowserWindow::WebContentsDestroyed() {
   CloseImmediately();
 }
 
-void BrowserWindow::OnCloseContents() {
-  BaseWindow::ResetBrowserViews();
-  api_web_contents_->Destroy();
-}
-
 void BrowserWindow::OnRendererResponsive(content::RenderProcessHost*) {
   window_unresponsive_closure_.Cancel();
   Emit("responsive");
@@ -297,13 +291,8 @@ void BrowserWindow::OnWindowIsKeyChanged(bool is_key) {
 
 void BrowserWindow::OnWindowResize() {
 #if BUILDFLAG(IS_MAC)
-  if (!draggable_regions_.empty()) {
+  if (!draggable_regions_.empty())
     UpdateDraggableRegions(draggable_regions_);
-  } else {
-    for (NativeBrowserView* view : window_->browser_views()) {
-      view->UpdateDraggableRegions(view->GetDraggableRegions());
-    }
-  }
 #endif
   BaseWindow::OnWindowResize();
 }
@@ -371,45 +360,6 @@ void BrowserWindow::SetBackgroundColor(const std::string& color_name) {
   }
 }
 
-void BrowserWindow::SetBrowserView(
-    absl::optional<gin::Handle<BrowserView>> browser_view) {
-  BaseWindow::ResetBrowserViews();
-  if (browser_view)
-    BaseWindow::AddBrowserView(*browser_view);
-#if BUILDFLAG(IS_MAC)
-  UpdateDraggableRegions(draggable_regions_);
-#endif
-}
-
-void BrowserWindow::AddBrowserView(gin::Handle<BrowserView> browser_view) {
-  BaseWindow::AddBrowserView(browser_view);
-#if BUILDFLAG(IS_MAC)
-  UpdateDraggableRegions(draggable_regions_);
-#endif
-}
-
-void BrowserWindow::RemoveBrowserView(gin::Handle<BrowserView> browser_view) {
-  BaseWindow::RemoveBrowserView(browser_view);
-#if BUILDFLAG(IS_MAC)
-  UpdateDraggableRegions(draggable_regions_);
-#endif
-}
-
-void BrowserWindow::SetTopBrowserView(gin::Handle<BrowserView> browser_view,
-                                      gin_helper::Arguments* args) {
-  BaseWindow::SetTopBrowserView(browser_view, args);
-#if BUILDFLAG(IS_MAC)
-  UpdateDraggableRegions(draggable_regions_);
-#endif
-}
-
-void BrowserWindow::ResetBrowserViews() {
-  BaseWindow::ResetBrowserViews();
-#if BUILDFLAG(IS_MAC)
-  UpdateDraggableRegions(draggable_regions_);
-#endif
-}
-
 void BrowserWindow::OnDevToolsResized() {
   UpdateDraggableRegions(draggable_regions_);
 }

shell/browser/api/electron_api_browser_window.h

@@ -56,7 +56,6 @@ class BrowserWindow : public BaseWindow,
   void WebContentsDestroyed() override;
 
   // ExtendedWebContentsObserver:
-  void OnCloseContents() override;
   void OnDraggableRegionsUpdated(
       const std::vector<mojom::DraggableRegionPtr>& regions) override;
   void OnSetContentBounds(const gfx::Rect& rect) override;
@@ -80,13 +79,6 @@ class BrowserWindow : public BaseWindow,
   void Focus() override;
   void Blur() override;
   void SetBackgroundColor(const std::string& color_name) override;
-  void SetBrowserView(
-      absl::optional<gin::Handle<BrowserView>> browser_view) override;
-  void AddBrowserView(gin::Handle<BrowserView> browser_view) override;
-  void RemoveBrowserView(gin::Handle<BrowserView> browser_view) override;
-  void SetTopBrowserView(gin::Handle<BrowserView> browser_view,
-                         gin_helper::Arguments* args) override;
-  void ResetBrowserViews() override;
   void OnWindowShow() override;
   void OnWindowHide() override;
 

shell/browser/api/electron_api_browser_window_mac.mm

@@ -10,7 +10,6 @@
 #import <Cocoa/Cocoa.h>
 
 #include "base/mac/scoped_nsobject.h"
-#include "shell/browser/native_browser_view.h"
 #include "shell/browser/native_window_mac.h"
 #include "shell/browser/ui/cocoa/electron_inspectable_web_contents_view.h"
 #include "shell/browser/ui/inspectable_web_contents_view.h"
@@ -73,15 +72,6 @@ void BrowserWindow::UpdateDraggableRegions(
         DraggableRegionsToSkRegion(regions), webViewWidth, webViewHeight);
   }
 
-  // Draggable regions on BrowserViews are independent from those of
-  // BrowserWindows, so if a BrowserView with different draggable regions than
-  // the BrowserWindow it belongs to is superimposed on top of that window, the
-  // draggable regions of the BrowserView take precedence over those of the
-  // BrowserWindow.
-  for (NativeBrowserView* view : window_->browser_views()) {
-    view->UpdateDraggableRegions(view->GetDraggableRegions());
-  }
-
   // Create and add a ControlRegionView for each region that needs to be
   // excluded from the dragging.
   for (const auto& rect : drag_exclude_rects) {

shell/browser/api/electron_api_web_contents.cc

@@ -318,9 +318,6 @@ struct Converter<electron::api::WebContents::Type> {
       case Type::kBrowserWindow:
         type = "window";
         break;
-      case Type::kBrowserView:
-        type = "browserView";
-        break;
       case Type::kRemote:
         type = "remote";
         break;
@@ -345,8 +342,6 @@ struct Converter<electron::api::WebContents::Type> {
       return false;
     if (type == "backgroundPage") {
       *out = Type::kBackgroundPage;
-    } else if (type == "browserView") {
-      *out = Type::kBrowserView;
     } else if (type == "webview") {
       *out = Type::kWebView;
 #if BUILDFLAG(ENABLE_OSR)
@@ -739,10 +734,7 @@ WebContents::WebContents(v8::Isolate* isolate,
   // Whether to enable DevTools.
   options.Get("devTools", &enable_devtools_);
 
-  // BrowserViews are not attached to a window initially so they should start
-  // off as hidden. This is also important for compositor recycling. See:
-  // https://github.com/electron/electron/pull/21372
-  bool initially_shown = type_ != Type::kBrowserView;
+  bool initially_shown = true;
   options.Get(options::kShow, &initially_shown);
 
   // Obtain the session.
@@ -1169,8 +1161,7 @@ content::WebContents* WebContents::OpenURLFromTab(
 void WebContents::BeforeUnloadFired(content::WebContents* tab,
                                     bool proceed,
                                     bool* proceed_to_fire_unload) {
-  if (type_ == Type::kBrowserWindow || type_ == Type::kOffScreen ||
-      type_ == Type::kBrowserView)
+  if (type_ == Type::kBrowserWindow || type_ == Type::kOffScreen)
     *proceed_to_fire_unload = proceed;
   else
     *proceed_to_fire_unload = true;
@@ -1491,7 +1482,7 @@ void WebContents::HandleNewRenderFrame(
     absl::optional<SkColor> maybe_color = web_preferences->GetBackgroundColor();
     web_contents()->SetPageBaseBackgroundColor(maybe_color);
 
-    bool guest = IsGuest() || type_ == Type::kBrowserView;
+    bool guest = IsGuest();
     SkColor color =
         maybe_color.value_or(guest ? SK_ColorTRANSPARENT : SK_ColorWHITE);
     SetBackgroundColor(rwhv, color);

shell/browser/api/electron_api_web_contents.h

@@ -109,7 +109,6 @@ class WebContents : public ExclusiveAccessContext,
   enum class Type {
     kBackgroundPage,  // An extension background page.
     kBrowserWindow,   // Used by BrowserWindow.
-    kBrowserView,     // Used by BrowserView.
     kRemote,          // Thin wrap around an existing WebContents.
     kWebView,         // Used by <webview>.
     kOffScreen,       // Used for offscreen rendering

shell/browser/native_browser_view.cc

@@ -1,30 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "shell/browser/native_browser_view.h"
-
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/browser/ui/inspectable_web_contents.h"
-
-namespace electron {
-
-NativeBrowserView::NativeBrowserView(
-    InspectableWebContents* inspectable_web_contents)
-    : inspectable_web_contents_(inspectable_web_contents) {
-  Observe(inspectable_web_contents_->GetWebContents());
-}
-
-NativeBrowserView::~NativeBrowserView() = default;
-
-InspectableWebContentsView* NativeBrowserView::GetInspectableWebContentsView() {
-  if (!inspectable_web_contents_)
-    return nullptr;
-  return inspectable_web_contents_->GetView();
-}
-
-void NativeBrowserView::WebContentsDestroyed() {
-  inspectable_web_contents_ = nullptr;
-}
-
-}  // namespace electron

shell/browser/native_browser_view.h

@@ -1,75 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_H_
-#define ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_H_
-
-#include <vector>
-
-#include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_observer.h"
-#include "shell/common/api/api.mojom.h"
-#include "third_party/skia/include/core/SkColor.h"
-
-namespace gfx {
-class Rect;
-}
-
-namespace electron {
-
-enum AutoResizeFlags {
-  kAutoResizeWidth = 0x1,
-  kAutoResizeHeight = 0x2,
-  kAutoResizeHorizontal = 0x4,
-  kAutoResizeVertical = 0x8,
-};
-
-class InspectableWebContents;
-class InspectableWebContentsView;
-
-class NativeBrowserView : public content::WebContentsObserver {
- public:
-  ~NativeBrowserView() override;
-
-  // disable copy
-  NativeBrowserView(const NativeBrowserView&) = delete;
-  NativeBrowserView& operator=(const NativeBrowserView&) = delete;
-
-  static NativeBrowserView* Create(
-      InspectableWebContents* inspectable_web_contents);
-
-  InspectableWebContents* GetInspectableWebContents() {
-    return inspectable_web_contents_;
-  }
-
-  const std::vector<mojom::DraggableRegionPtr>& GetDraggableRegions() const {
-    return draggable_regions_;
-  }
-
-  InspectableWebContentsView* GetInspectableWebContentsView();
-
-  virtual void SetAutoResizeFlags(uint8_t flags) = 0;
-  virtual void SetBounds(const gfx::Rect& bounds) = 0;
-  virtual gfx::Rect GetBounds() = 0;
-  virtual void SetBackgroundColor(SkColor color) = 0;
-
-  virtual void UpdateDraggableRegions(
-      const std::vector<gfx::Rect>& drag_exclude_rects) {}
-
-  // Called when the window needs to update its draggable region.
-  virtual void UpdateDraggableRegions(
-      const std::vector<mojom::DraggableRegionPtr>& regions) {}
-
- protected:
-  explicit NativeBrowserView(InspectableWebContents* inspectable_web_contents);
-  // content::WebContentsObserver:
-  void WebContentsDestroyed() override;
-
-  InspectableWebContents* inspectable_web_contents_;
-  std::vector<mojom::DraggableRegionPtr> draggable_regions_;
-};
-
-}  // namespace electron
-
-#endif  // ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_H_

shell/browser/native_browser_view_mac.h

@@ -1,36 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_MAC_H_
-#define ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_MAC_H_
-
-#import <Cocoa/Cocoa.h>
-#include <vector>
-
-#include "base/mac/scoped_nsobject.h"
-#include "shell/browser/native_browser_view.h"
-
-namespace electron {
-
-class NativeBrowserViewMac : public NativeBrowserView {
- public:
-  explicit NativeBrowserViewMac(
-      InspectableWebContents* inspectable_web_contents);
-  ~NativeBrowserViewMac() override;
-
-  void SetAutoResizeFlags(uint8_t flags) override;
-  void SetBounds(const gfx::Rect& bounds) override;
-  gfx::Rect GetBounds() override;
-  void SetBackgroundColor(SkColor color) override;
-
-  void UpdateDraggableRegions(
-      const std::vector<mojom::DraggableRegionPtr>& regions) override;
-
-  void UpdateDraggableRegions(
-      const std::vector<gfx::Rect>& drag_exclude_rects) override;
-};
-
-}  // namespace electron
-
-#endif  // ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_MAC_H_

shell/browser/native_browser_view_mac.mm

@@ -1,393 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "shell/browser/native_browser_view_mac.h"
-
-#import <objc/runtime.h>
-#include <vector>
-
-#include "shell/browser/ui/drag_util.h"
-#include "shell/browser/ui/inspectable_web_contents.h"
-#include "shell/browser/ui/inspectable_web_contents_view.h"
-#include "skia/ext/skia_utils_mac.h"
-#include "ui/gfx/geometry/rect.h"
-
-// Match view::Views behavior where the view sticks to the top-left origin.
-const NSAutoresizingMaskOptions kDefaultAutoResizingMask =
-    NSViewMaxXMargin | NSViewMinYMargin;
-
-@interface DragRegionView : NSView
-
-@property(assign) NSPoint initialLocation;
-
-@end
-
-@interface NSWindow ()
-- (void)performWindowDragWithEvent:(NSEvent*)event;
-@end
-
-@implementation DragRegionView
-
-@synthesize initialLocation;
-
-+ (void)load {
-  if (getenv("ELECTRON_DEBUG_DRAG_REGIONS")) {
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-      SEL originalSelector = @selector(drawRect:);
-      SEL swizzledSelector = @selector(drawDebugRect:);
-
-      Method originalMethod =
-          class_getInstanceMethod([self class], originalSelector);
-      Method swizzledMethod =
-          class_getInstanceMethod([self class], swizzledSelector);
-      BOOL didAddMethod =
-          class_addMethod([self class], originalSelector,
-                          method_getImplementation(swizzledMethod),
-                          method_getTypeEncoding(swizzledMethod));
-
-      if (didAddMethod) {
-        class_replaceMethod([self class], swizzledSelector,
-                            method_getImplementation(originalMethod),
-                            method_getTypeEncoding(originalMethod));
-      } else {
-        method_exchangeImplementations(originalMethod, swizzledMethod);
-      }
-    });
-  }
-}
-
-- (BOOL)mouseDownCanMoveWindow {
-  return
-      [self.window respondsToSelector:@selector(performWindowDragWithEvent:)];
-}
-
-- (BOOL)acceptsFirstMouse:(NSEvent*)event {
-  return YES;
-}
-
-- (BOOL)shouldIgnoreMouseEvent {
-  NSEventType type = [[NSApp currentEvent] type];
-  return type != NSEventTypeLeftMouseDragged &&
-         type != NSEventTypeLeftMouseDown;
-}
-
-- (NSView*)hitTest:(NSPoint)point {
-  // Pass-through events that hit one of the exclusion zones
-  for (NSView* exclusion_zones in [self subviews]) {
-    if ([exclusion_zones hitTest:point])
-      return nil;
-  }
-
-  return self;
-}
-
-- (void)mouseDown:(NSEvent*)event {
-  [super mouseDown:event];
-
-  if ([self.window respondsToSelector:@selector(performWindowDragWithEvent:)]) {
-    // According to Google, using performWindowDragWithEvent:
-    // does not generate a NSWindowWillMoveNotification. Hence post one.
-    [[NSNotificationCenter defaultCenter]
-        postNotificationName:NSWindowWillMoveNotification
-                      object:self];
-
-    [self.window performWindowDragWithEvent:event];
-
-    return;
-  }
-
-  if (self.window.styleMask & NSWindowStyleMaskFullScreen) {
-    return;
-  }
-
-  self.initialLocation = [event locationInWindow];
-}
-
-- (void)mouseDragged:(NSEvent*)event {
-  if ([self.window respondsToSelector:@selector(performWindowDragWithEvent:)]) {
-    return;
-  }
-
-  if (self.window.styleMask & NSWindowStyleMaskFullScreen) {
-    return;
-  }
-
-  NSPoint currentLocation = [NSEvent mouseLocation];
-  NSPoint newOrigin;
-
-  NSRect screenFrame = [[NSScreen mainScreen] frame];
-  NSSize screenSize = screenFrame.size;
-  NSRect windowFrame = [self.window frame];
-  NSSize windowSize = windowFrame.size;
-
-  newOrigin.x = currentLocation.x - self.initialLocation.x;
-  newOrigin.y = currentLocation.y - self.initialLocation.y;
-
-  BOOL inMenuBar = (newOrigin.y + windowSize.height) >
-                   (screenFrame.origin.y + screenSize.height);
-  BOOL screenAboveMainScreen = false;
-
-  if (inMenuBar) {
-    for (NSScreen* screen in [NSScreen screens]) {
-      NSRect currentScreenFrame = [screen frame];
-      BOOL isHigher = currentScreenFrame.origin.y > screenFrame.origin.y;
-
-      // If there's another screen that is generally above the current screen,
-      // we'll draw a new rectangle that is just above the current screen. If
-      // the "higher" screen intersects with this rectangle, we'll allow drawing
-      // above the menubar.
-      if (isHigher) {
-        NSRect aboveScreenRect =
-            NSMakeRect(screenFrame.origin.x,
-                       screenFrame.origin.y + screenFrame.size.height - 10,
-                       screenFrame.size.width, 200);
-
-        BOOL screenAboveIntersects =
-            NSIntersectsRect(currentScreenFrame, aboveScreenRect);
-
-        if (screenAboveIntersects) {
-          screenAboveMainScreen = true;
-          break;
-        }
-      }
-    }
-  }
-
-  // Don't let window get dragged up under the menu bar
-  if (inMenuBar && !screenAboveMainScreen) {
-    newOrigin.y = screenFrame.origin.y +
-                  (screenFrame.size.height - windowFrame.size.height);
-  }
-
-  // Move the window to the new location
-  [self.window setFrameOrigin:newOrigin];
-}
-
-// For debugging purposes only.
-- (void)drawDebugRect:(NSRect)aRect {
-  [[[NSColor greenColor] colorWithAlphaComponent:0.5] set];
-  NSRectFill([self bounds]);
-}
-
-@end
-
-@interface ExcludeDragRegionView : NSView
-@end
-
-@implementation ExcludeDragRegionView
-
-+ (void)load {
-  if (getenv("ELECTRON_DEBUG_DRAG_REGIONS")) {
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-      SEL originalSelector = @selector(drawRect:);
-      SEL swizzledSelector = @selector(drawDebugRect:);
-
-      Method originalMethod =
-          class_getInstanceMethod([self class], originalSelector);
-      Method swizzledMethod =
-          class_getInstanceMethod([self class], swizzledSelector);
-      BOOL didAddMethod =
-          class_addMethod([self class], originalSelector,
-                          method_getImplementation(swizzledMethod),
-                          method_getTypeEncoding(swizzledMethod));
-
-      if (didAddMethod) {
-        class_replaceMethod([self class], swizzledSelector,
-                            method_getImplementation(originalMethod),
-                            method_getTypeEncoding(originalMethod));
-      } else {
-        method_exchangeImplementations(originalMethod, swizzledMethod);
-      }
-    });
-  }
-}
-
-- (BOOL)mouseDownCanMoveWindow {
-  return NO;
-}
-
-// For debugging purposes only.
-- (void)drawDebugRect:(NSRect)aRect {
-  [[[NSColor redColor] colorWithAlphaComponent:0.5] set];
-  NSRectFill([self bounds]);
-}
-
-@end
-
-namespace electron {
-
-NativeBrowserViewMac::NativeBrowserViewMac(
-    InspectableWebContents* inspectable_web_contents)
-    : NativeBrowserView(inspectable_web_contents) {
-  auto* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetNativeView().GetNativeNSView();
-  view.autoresizingMask = kDefaultAutoResizingMask;
-}
-
-NativeBrowserViewMac::~NativeBrowserViewMac() = default;
-
-void NativeBrowserViewMac::SetAutoResizeFlags(uint8_t flags) {
-  NSAutoresizingMaskOptions autoresizing_mask = kDefaultAutoResizingMask;
-  if (flags & kAutoResizeWidth) {
-    autoresizing_mask |= NSViewWidthSizable;
-  }
-  if (flags & kAutoResizeHeight) {
-    autoresizing_mask |= NSViewHeightSizable;
-  }
-  if (flags & kAutoResizeHorizontal) {
-    autoresizing_mask |=
-        NSViewMaxXMargin | NSViewMinXMargin | NSViewWidthSizable;
-  }
-  if (flags & kAutoResizeVertical) {
-    autoresizing_mask |=
-        NSViewMaxYMargin | NSViewMinYMargin | NSViewHeightSizable;
-  }
-
-  auto* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetNativeView().GetNativeNSView();
-  view.autoresizingMask = autoresizing_mask;
-}
-
-void NativeBrowserViewMac::SetBounds(const gfx::Rect& bounds) {
-  auto* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetNativeView().GetNativeNSView();
-  auto* superview = view.superview;
-  const auto superview_height = superview ? superview.frame.size.height : 0;
-
-  // We need to use the content rect to calculate the titlebar height if the
-  // superview is an framed NSWindow, otherwise it will be offset incorrectly by
-  // the height of the titlebar.
-  auto titlebar_height = 0;
-  if (auto* win = [superview window]) {
-    const auto content_rect_height =
-        [win contentRectForFrameRect:superview.frame].size.height;
-    titlebar_height = superview_height - content_rect_height;
-  }
-
-  auto new_height =
-      superview_height - bounds.y() - bounds.height() + titlebar_height;
-  view.frame =
-      NSMakeRect(bounds.x(), new_height, bounds.width(), bounds.height());
-
-  // Ensure draggable regions are properly updated to reflect new bounds.
-  UpdateDraggableRegions(draggable_regions_);
-}
-
-gfx::Rect NativeBrowserViewMac::GetBounds() {
-  auto* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return gfx::Rect();
-  NSView* view = iwc_view->GetNativeView().GetNativeNSView();
-  auto* superview = view.superview;
-  const int superview_height = superview ? superview.frame.size.height : 0;
-
-  // We need to use the content rect to calculate the titlebar height if the
-  // superview is an framed NSWindow, otherwise it will be offset incorrectly by
-  // the height of the titlebar.
-  auto titlebar_height = 0;
-  if (auto* win = [superview window]) {
-    const auto content_rect_height =
-        [win contentRectForFrameRect:superview.frame].size.height;
-    titlebar_height = superview_height - content_rect_height;
-  }
-
-  auto new_height = superview_height - view.frame.origin.y -
-                    view.frame.size.height + titlebar_height;
-  return gfx::Rect(view.frame.origin.x, new_height, view.frame.size.width,
-                   view.frame.size.height);
-}
-
-void NativeBrowserViewMac::SetBackgroundColor(SkColor color) {
-  auto* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetNativeView().GetNativeNSView();
-  view.wantsLayer = YES;
-  view.layer.backgroundColor = skia::CGColorCreateFromSkColor(color);
-}
-
-void NativeBrowserViewMac::UpdateDraggableRegions(
-    const std::vector<gfx::Rect>& drag_exclude_rects) {
-  if (!inspectable_web_contents_)
-    return;
-  auto* web_contents = inspectable_web_contents_->GetWebContents();
-  auto* iwc_view = GetInspectableWebContentsView();
-  NSView* web_view = web_contents->GetNativeView().GetNativeNSView();
-  NSView* inspectable_view = iwc_view->GetNativeView().GetNativeNSView();
-  NSView* window_content_view = inspectable_view.superview;
-
-  // Remove all DragRegionViews that were added last time. Note that we need
-  // to copy the `subviews` array to avoid mutation during iteration.
-  base::scoped_nsobject<NSArray> subviews([[web_view subviews] copy]);
-  for (NSView* subview in subviews.get()) {
-    if ([subview isKindOfClass:[DragRegionView class]]) {
-      [subview removeFromSuperview];
-    }
-  }
-
-  // Create one giant NSView that is draggable.
-  base::scoped_nsobject<NSView> drag_region_view(
-      [[DragRegionView alloc] initWithFrame:web_view.bounds]);
-  [web_view addSubview:drag_region_view];
-
-  // Then, on top of that, add "exclusion zones".
-  auto const offset = GetBounds().OffsetFromOrigin();
-  const auto window_content_view_height = NSHeight(window_content_view.bounds);
-  for (const auto& rect : drag_exclude_rects) {
-    const auto x = rect.x() + offset.x();
-    const auto y = window_content_view_height - (rect.bottom() + offset.y());
-    const auto exclude_rect = NSMakeRect(x, y, rect.width(), rect.height());
-
-    const auto drag_region_view_exclude_rect =
-        [window_content_view convertRect:exclude_rect toView:drag_region_view];
-
-    base::scoped_nsobject<NSView> exclude_drag_region_view(
-        [[ExcludeDragRegionView alloc]
-            initWithFrame:drag_region_view_exclude_rect]);
-    [drag_region_view addSubview:exclude_drag_region_view];
-  }
-}
-
-void NativeBrowserViewMac::UpdateDraggableRegions(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
-  if (!inspectable_web_contents_)
-    return;
-  auto* web_contents = inspectable_web_contents_->GetWebContents();
-  NSView* web_view = web_contents->GetNativeView().GetNativeNSView();
-
-  NSInteger webViewWidth = NSWidth([web_view bounds]);
-  NSInteger webViewHeight = NSHeight([web_view bounds]);
-
-  // Draggable regions are implemented by having the whole web view draggable
-  // and overlaying regions that are not draggable.
-  if (&draggable_regions_ != &regions)
-    draggable_regions_ = mojo::Clone(regions);
-
-  std::vector<gfx::Rect> drag_exclude_rects;
-  if (draggable_regions_.empty()) {
-    drag_exclude_rects.emplace_back(0, 0, webViewWidth, webViewHeight);
-  } else {
-    drag_exclude_rects = CalculateNonDraggableRegions(
-        DraggableRegionsToSkRegion(draggable_regions_), webViewWidth,
-        webViewHeight);
-  }
-
-  UpdateDraggableRegions(drag_exclude_rects);
-}
-
-// static
-NativeBrowserView* NativeBrowserView::Create(
-    InspectableWebContents* inspectable_web_contents) {
-  return new NativeBrowserViewMac(inspectable_web_contents);
-}
-
-}  // namespace electron

shell/browser/native_browser_view_views.cc

@@ -1,168 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "shell/browser/native_browser_view_views.h"
-
-#include <vector>
-
-#include "shell/browser/ui/drag_util.h"
-#include "shell/browser/ui/views/inspectable_web_contents_view_views.h"
-#include "ui/gfx/geometry/rect.h"
-#include "ui/views/background.h"
-#include "ui/views/view.h"
-
-namespace electron {
-
-NativeBrowserViewViews::NativeBrowserViewViews(
-    InspectableWebContents* inspectable_web_contents)
-    : NativeBrowserView(inspectable_web_contents) {}
-
-NativeBrowserViewViews::~NativeBrowserViewViews() = default;
-
-void NativeBrowserViewViews::SetAutoResizeFlags(uint8_t flags) {
-  auto_resize_flags_ = flags;
-  ResetAutoResizeProportions();
-}
-
-void NativeBrowserViewViews::UpdateDraggableRegions(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
-  if (&draggable_regions_ != &regions)
-    draggable_regions_ = mojo::Clone(regions);
-
-  // We need to snap the regions to the bounds of the current BrowserView.
-  // For example, if an attached BrowserView is draggable but its bounds are
-  // { x: 200,  y: 100, width: 300, height: 300 }
-  // then we need to add 200 to the x-value and 100 to the
-  // y-value of each of the passed regions or it will be incorrectly
-  // assumed that the regions begin in the top left corner as they
-  // would for the main client window.
-  auto const offset = GetBounds().OffsetFromOrigin();
-  for (auto& snapped_region : draggable_regions_) {
-    snapped_region->bounds.Offset(offset);
-  }
-  draggable_region_ = DraggableRegionsToSkRegion(draggable_regions_);
-}
-
-void NativeBrowserViewViews::SetAutoResizeProportions(
-    const gfx::Size& window_size) {
-  if ((auto_resize_flags_ & AutoResizeFlags::kAutoResizeHorizontal) &&
-      !auto_horizontal_proportion_set_) {
-    InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-    if (!iwc_view)
-      return;
-    auto* view = iwc_view->GetView();
-    auto view_bounds = view->bounds();
-    auto_horizontal_proportion_width_ =
-        static_cast<float>(window_size.width()) /
-        static_cast<float>(view_bounds.width());
-    auto_horizontal_proportion_left_ = static_cast<float>(window_size.width()) /
-                                       static_cast<float>(view_bounds.x());
-    auto_horizontal_proportion_set_ = true;
-  }
-  if ((auto_resize_flags_ & AutoResizeFlags::kAutoResizeVertical) &&
-      !auto_vertical_proportion_set_) {
-    InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-    if (!iwc_view)
-      return;
-    auto* view = iwc_view->GetView();
-    auto view_bounds = view->bounds();
-    auto_vertical_proportion_height_ =
-        static_cast<float>(window_size.height()) /
-        static_cast<float>(view_bounds.height());
-    auto_vertical_proportion_top_ = static_cast<float>(window_size.height()) /
-                                    static_cast<float>(view_bounds.y());
-    auto_vertical_proportion_set_ = true;
-  }
-}
-
-void NativeBrowserViewViews::AutoResize(const gfx::Rect& new_window,
-                                        int width_delta,
-                                        int height_delta) {
-  InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetView();
-  const auto flags = GetAutoResizeFlags();
-  if (!(flags & kAutoResizeWidth)) {
-    width_delta = 0;
-  }
-  if (!(flags & kAutoResizeHeight)) {
-    height_delta = 0;
-  }
-  if (height_delta || width_delta) {
-    auto new_view_size = view->size();
-    new_view_size.set_width(new_view_size.width() + width_delta);
-    new_view_size.set_height(new_view_size.height() + height_delta);
-    view->SetSize(new_view_size);
-  }
-  auto new_view_bounds = view->bounds();
-  if (flags & kAutoResizeHorizontal) {
-    new_view_bounds.set_width(new_window.width() /
-                              auto_horizontal_proportion_width_);
-    new_view_bounds.set_x(new_window.width() /
-                          auto_horizontal_proportion_left_);
-  }
-  if (flags & kAutoResizeVertical) {
-    new_view_bounds.set_height(new_window.height() /
-                               auto_vertical_proportion_height_);
-    new_view_bounds.set_y(new_window.height() / auto_vertical_proportion_top_);
-  }
-  if ((flags & kAutoResizeHorizontal) || (flags & kAutoResizeVertical)) {
-    view->SetBoundsRect(new_view_bounds);
-  }
-}
-
-void NativeBrowserViewViews::ResetAutoResizeProportions() {
-  if (auto_resize_flags_ & AutoResizeFlags::kAutoResizeHorizontal) {
-    auto_horizontal_proportion_set_ = false;
-  }
-  if (auto_resize_flags_ & AutoResizeFlags::kAutoResizeVertical) {
-    auto_vertical_proportion_set_ = false;
-  }
-}
-
-void NativeBrowserViewViews::SetBounds(const gfx::Rect& bounds) {
-  InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetView();
-  view->SetBoundsRect(bounds);
-  ResetAutoResizeProportions();
-
-  view->InvalidateLayout();
-  view->SchedulePaint();
-
-  // Ensure draggable regions are properly updated to reflect new bounds.
-  UpdateDraggableRegions(draggable_regions_);
-}
-
-gfx::Rect NativeBrowserViewViews::GetBounds() {
-  InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return gfx::Rect();
-  return iwc_view->GetView()->bounds();
-}
-
-void NativeBrowserViewViews::RenderViewReady() {
-  InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-  if (iwc_view)
-    iwc_view->GetView()->Layout();
-}
-
-void NativeBrowserViewViews::SetBackgroundColor(SkColor color) {
-  InspectableWebContentsView* iwc_view = GetInspectableWebContentsView();
-  if (!iwc_view)
-    return;
-  auto* view = iwc_view->GetView();
-  view->SetBackground(views::CreateSolidBackground(color));
-  view->SchedulePaint();
-}
-
-// static
-NativeBrowserView* NativeBrowserView::Create(
-    InspectableWebContents* inspectable_web_contents) {
-  return new NativeBrowserViewViews(inspectable_web_contents);
-}
-
-}  // namespace electron

shell/browser/native_browser_view_views.h

@@ -1,59 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_VIEWS_H_
-#define ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_VIEWS_H_
-
-#include <memory>
-#include <vector>
-
-#include "shell/browser/native_browser_view.h"
-#include "third_party/skia/include/core/SkRegion.h"
-
-namespace electron {
-
-class NativeBrowserViewViews : public NativeBrowserView {
- public:
-  explicit NativeBrowserViewViews(
-      InspectableWebContents* inspectable_web_contents);
-  ~NativeBrowserViewViews() override;
-
-  void SetAutoResizeProportions(const gfx::Size& window_size);
-  void AutoResize(const gfx::Rect& new_window,
-                  int width_delta,
-                  int height_delta);
-  uint8_t GetAutoResizeFlags() { return auto_resize_flags_; }
-
-  // NativeBrowserView:
-  void SetAutoResizeFlags(uint8_t flags) override;
-  void SetBounds(const gfx::Rect& bounds) override;
-  gfx::Rect GetBounds() override;
-  void SetBackgroundColor(SkColor color) override;
-  void UpdateDraggableRegions(
-      const std::vector<mojom::DraggableRegionPtr>& regions) override;
-
-  // WebContentsObserver:
-  void RenderViewReady() override;
-
-  SkRegion* draggable_region() const { return draggable_region_.get(); }
-
- private:
-  void ResetAutoResizeProportions();
-
-  uint8_t auto_resize_flags_ = 0;
-
-  bool auto_horizontal_proportion_set_ = false;
-  float auto_horizontal_proportion_width_ = 0.;
-  float auto_horizontal_proportion_left_ = 0.;
-
-  bool auto_vertical_proportion_set_ = false;
-  float auto_vertical_proportion_height_ = 0.;
-  float auto_vertical_proportion_top_ = 0.;
-
-  std::unique_ptr<SkRegion> draggable_region_;
-};
-
-}  // namespace electron
-
-#endif  // ELECTRON_SHELL_BROWSER_NATIVE_BROWSER_VIEW_VIEWS_H_

shell/browser/native_window.h

@@ -45,7 +45,6 @@ class PersistentDictionary;
 namespace electron {
 
 class ElectronMenuModel;
-class NativeBrowserView;
 
 #if BUILDFLAG(IS_MAC)
 typedef NSView* NativeWindowHandle;
@@ -174,9 +173,6 @@ class NativeWindow : public base::SupportsUserData,
   virtual bool IsFocusable();
   virtual void SetMenu(ElectronMenuModel* menu);
   virtual void SetParentWindow(NativeWindow* parent);
-  virtual void AddBrowserView(NativeBrowserView* browser_view) = 0;
-  virtual void RemoveBrowserView(NativeBrowserView* browser_view) = 0;
-  virtual void SetTopBrowserView(NativeBrowserView* browser_view) = 0;
   virtual content::DesktopMediaID GetDesktopMediaID() const = 0;
   virtual gfx::NativeView GetNativeView() const = 0;
   virtual gfx::NativeWindow GetNativeWindow() const = 0;
@@ -365,8 +361,6 @@ class NativeWindow : public base::SupportsUserData,
   NativeWindow* parent() const { return parent_; }
   bool is_modal() const { return is_modal_; }
 
-  std::list<NativeBrowserView*> browser_views() const { return browser_views_; }
-
   int32_t window_id() const { return next_id_; }
 
  protected:
@@ -379,14 +373,6 @@ class NativeWindow : public base::SupportsUserData,
 
   void set_content_view(views::View* view) { content_view_ = view; }
 
-  void add_browser_view(NativeBrowserView* browser_view) {
-    browser_views_.push_back(browser_view);
-  }
-  void remove_browser_view(NativeBrowserView* browser_view) {
-    browser_views_.remove_if(
-        [&browser_view](NativeBrowserView* n) { return (n == browser_view); });
-  }
-
   // The boolean parsing of the "titleBarOverlay" option
   bool titlebar_overlay_ = false;
 
@@ -447,9 +433,6 @@ class NativeWindow : public base::SupportsUserData,
   // Is this a modal window.
   bool is_modal_ = false;
 
-  // The browser view layer.
-  std::list<NativeBrowserView*> browser_views_;
-
   // Observers of this window.
   base::ObserverList<NativeWindowObserver> observers_;
 

shell/browser/native_window_mac.h

@@ -105,9 +105,6 @@ class NativeWindowMac : public NativeWindow,
   void SetContentProtection(bool enable) override;
   void SetFocusable(bool focusable) override;
   bool IsFocusable() override;
-  void AddBrowserView(NativeBrowserView* browser_view) override;
-  void RemoveBrowserView(NativeBrowserView* browser_view) override;
-  void SetTopBrowserView(NativeBrowserView* browser_view) override;
   void SetParentWindow(NativeWindow* parent) override;
   content::DesktopMediaID GetDesktopMediaID() const override;
   gfx::NativeView GetNativeView() const override;

shell/browser/native_window_mac.mm

@@ -23,7 +23,6 @@
 #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"
@@ -1208,70 +1207,6 @@ bool NativeWindowMac::IsFocusable() {
   return ![window_ disableKeyOrMainWindow];
 }
 
-void NativeWindowMac::AddBrowserView(NativeBrowserView* view) {
-  [CATransaction begin];
-  [CATransaction setDisableActions:YES];
-
-  if (!view) {
-    [CATransaction commit];
-    return;
-  }
-
-  add_browser_view(view);
-  if (view->GetInspectableWebContentsView()) {
-    auto* native_view = view->GetInspectableWebContentsView()
-                            ->GetNativeView()
-                            .GetNativeNSView();
-    [[window_ contentView] addSubview:native_view
-                           positioned:NSWindowAbove
-                           relativeTo:nil];
-    native_view.hidden = NO;
-  }
-
-  [CATransaction commit];
-}
-
-void NativeWindowMac::RemoveBrowserView(NativeBrowserView* view) {
-  [CATransaction begin];
-  [CATransaction setDisableActions:YES];
-
-  if (!view) {
-    [CATransaction commit];
-    return;
-  }
-
-  if (view->GetInspectableWebContentsView())
-    [view->GetInspectableWebContentsView()->GetNativeView().GetNativeNSView()
-        removeFromSuperview];
-  remove_browser_view(view);
-
-  [CATransaction commit];
-}
-
-void NativeWindowMac::SetTopBrowserView(NativeBrowserView* view) {
-  [CATransaction begin];
-  [CATransaction setDisableActions:YES];
-
-  if (!view) {
-    [CATransaction commit];
-    return;
-  }
-
-  remove_browser_view(view);
-  add_browser_view(view);
-  if (view->GetInspectableWebContentsView()) {
-    auto* native_view = view->GetInspectableWebContentsView()
-                            ->GetNativeView()
-                            .GetNativeNSView();
-    [[window_ contentView] addSubview:native_view
-                           positioned:NSWindowAbove
-                           relativeTo:nil];
-    native_view.hidden = NO;
-  }
-
-  [CATransaction commit];
-}
-
 void NativeWindowMac::SetParentWindow(NativeWindow* parent) {
   InternalSetParentWindow(parent, IsVisible());
 }

shell/browser/native_window_views.cc

@@ -18,7 +18,6 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/browser/native_browser_view_views.h"
 #include "shell/browser/ui/drag_util.h"
 #include "shell/browser/ui/inspectable_web_contents.h"
 #include "shell/browser/ui/inspectable_web_contents_view.h"
@@ -1273,50 +1272,6 @@ void NativeWindowViews::SetMenu(ElectronMenuModel* menu_model) {
   }
 }
 
-void NativeWindowViews::AddBrowserView(NativeBrowserView* view) {
-  if (!content_view())
-    return;
-
-  if (!view) {
-    return;
-  }
-
-  add_browser_view(view);
-  if (view->GetInspectableWebContentsView())
-    content_view()->AddChildView(
-        view->GetInspectableWebContentsView()->GetView());
-}
-
-void NativeWindowViews::RemoveBrowserView(NativeBrowserView* view) {
-  if (!content_view())
-    return;
-
-  if (!view) {
-    return;
-  }
-
-  if (view->GetInspectableWebContentsView())
-    content_view()->RemoveChildView(
-        view->GetInspectableWebContentsView()->GetView());
-  remove_browser_view(view);
-}
-
-void NativeWindowViews::SetTopBrowserView(NativeBrowserView* view) {
-  if (!content_view())
-    return;
-
-  if (!view) {
-    return;
-  }
-
-  remove_browser_view(view);
-  add_browser_view(view);
-
-  if (view->GetInspectableWebContentsView())
-    content_view()->ReorderChildView(
-        view->GetInspectableWebContentsView()->GetView(), -1);
-}
-
 void NativeWindowViews::SetParentWindow(NativeWindow* parent) {
   NativeWindow::SetParentWindow(parent);
 
@@ -1567,11 +1522,6 @@ void NativeWindowViews::OnWidgetBoundsChanged(views::Widget* changed_widget,
   if (widget_size_ != new_bounds.size()) {
     int width_delta = new_bounds.width() - widget_size_.width();
     int height_delta = new_bounds.height() - widget_size_.height();
-    for (NativeBrowserView* item : browser_views()) {
-      auto* native_view = static_cast<NativeBrowserViewViews*>(item);
-      native_view->SetAutoResizeProportions(widget_size_);
-      native_view->AutoResize(new_bounds, width_delta, height_delta);
-    }
 
     NotifyWindowResize();
     widget_size_ = new_bounds.size();
@@ -1615,16 +1565,6 @@ views::View* NativeWindowViews::GetContentsView() {
 bool NativeWindowViews::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
-  // App window should claim mouse events that fall within any BrowserViews'
-  // draggable region.
-  for (auto* view : browser_views()) {
-    auto* native_view = static_cast<NativeBrowserViewViews*>(view);
-    auto* view_draggable_region = native_view->draggable_region();
-    if (view_draggable_region &&
-        view_draggable_region->contains(location.x(), location.y()))
-      return false;
-  }
-
   // App window should claim mouse events that fall within the draggable region.
   if (draggable_region() &&
       draggable_region()->contains(location.x(), location.y()))

shell/browser/native_window_views.h

@@ -126,9 +126,6 @@ class NativeWindowViews : public NativeWindow,
   void SetFocusable(bool focusable) override;
   bool IsFocusable() override;
   void SetMenu(ElectronMenuModel* menu_model) override;
-  void AddBrowserView(NativeBrowserView* browser_view) override;
-  void RemoveBrowserView(NativeBrowserView* browser_view) override;
-  void SetTopBrowserView(NativeBrowserView* browser_view) override;
   void SetParentWindow(NativeWindow* parent) override;
   gfx::NativeView GetNativeView() const override;
   gfx::NativeWindow GetNativeWindow() const override;

shell/browser/ui/views/frameless_view.cc

@@ -4,7 +4,6 @@
 
 #include "shell/browser/ui/views/frameless_view.h"
 
-#include "shell/browser/native_browser_view_views.h"
 #include "shell/browser/native_window_views.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
@@ -79,15 +78,6 @@ int FramelessView::NonClientHitTest(const gfx::Point& cursor) {
   if (frame_->IsFullscreen())
     return HTCLIENT;
 
-  // Check attached BrowserViews for potential draggable areas.
-  for (auto* view : window_->browser_views()) {
-    auto* native_view = static_cast<NativeBrowserViewViews*>(view);
-    auto* view_draggable_region = native_view->draggable_region();
-    if (view_draggable_region &&
-        view_draggable_region->contains(cursor.x(), cursor.y()))
-      return HTCAPTION;
-  }
-
   // Support resizing frameless window by dragging the border.
   int frame_component = ResizingBorderHitTest(cursor);
   if (frame_component != HTNOWHERE)

shell/common/node_bindings.cc

@@ -46,7 +46,6 @@
 #define ELECTRON_BUILTIN_MODULES(V)      \
   V(electron_browser_app)                \
   V(electron_browser_auto_updater)       \
-  V(electron_browser_browser_view)       \
   V(electron_browser_content_tracing)    \
   V(electron_browser_crash_reporter)     \
   V(electron_browser_dialog)             \

typings/internal-ambient.d.ts

@@ -182,7 +182,6 @@ declare namespace NodeJS {
     _linkedBinding(name: 'electron_common_v8_util'): V8UtilBinding;
     _linkedBinding(name: 'electron_browser_app'): { app: Electron.App, App: Function };
     _linkedBinding(name: 'electron_browser_auto_updater'): { autoUpdater: Electron.AutoUpdater };
-    _linkedBinding(name: 'electron_browser_browser_view'): { BrowserView: typeof Electron.BrowserView };
     _linkedBinding(name: 'electron_browser_crash_reporter'): Omit<Electron.CrashReporter, 'start'> & {
       start(submitUrl: string,
         uploadToServer: boolean,

typings/internal-electron.d.ts

@@ -96,7 +96,7 @@ declare namespace Electron {
   interface WebPreferences {
     disablePopups?: boolean;
     embedder?: Electron.WebContents;
-    type?: 'backgroundPage' | 'window' | 'browserView' | 'remote' | 'webview' | 'offscreen';
+    type?: 'backgroundPage' | 'window' | 'remote' | 'webview' | 'offscreen';
   }
 
   interface Menu {
@@ -147,9 +147,10 @@ declare namespace Electron {
     _throw(error: Error | string): void;
   }
 
-  class View {}
 
   // Experimental views API
+  /*
+  class View {}
   class BaseWindow {
     constructor(args: {show: boolean})
     setContentView(view: View): void
@@ -162,6 +163,12 @@ declare namespace Electron {
   class WebContentsView {
     constructor(options: BrowserWindowConstructorOptions)
   }
+  namespace Main {
+    class BaseWindow extends Electron.BaseWindow {}
+    class View extends Electron.View {}
+    class WebContentsView extends Electron.WebContentsView {}
+  }
+  */
 
   // Deprecated / undocumented BrowserWindow methods
   interface BrowserWindow {
@@ -179,11 +186,6 @@ declare namespace Electron {
     setBackgroundThrottling(allowed: boolean): void;
   }
 
-  namespace Main {
-    class BaseWindow extends Electron.BaseWindow {}
-    class View extends Electron.View {}
-    class WebContentsView extends Electron.WebContentsView {}
-  }
 }
 
 declare namespace ElectronInternal {