Bump v19.0.0-nightly.20220203

* fix: WCO window hover on window controls

* Update shell/browser/ui/win/electron_desktop_window_tree_host_win.cc

Co-authored-by: Robo <hop2deep@gmail.com>

Co-authored-by: Robo <hop2deep@gmail.com>

BUILD.gn

@@ -501,6 +501,8 @@ source_set("electron_lib") {
       "StoreKit.framework",
     ]
 
+    weak_frameworks = [ "QuickLookThumbnailing.framework" ]
+
     sources += [
       "shell/browser/ui/views/autofill_popup_view.cc",
       "shell/browser/ui/views/autofill_popup_view.h",

ELECTRON_VERSION

@@ -1 +1 @@
-18.0.0-nightly.20220201
+19.0.0-nightly.20220203

build/args/all.gn

@@ -2,7 +2,7 @@ is_electron_build = true
 root_extra_deps = [ "//electron" ]
 
 # Registry of NMVs --> https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json
-node_module_version = 103
+node_module_version = 106
 
 v8_promise_internal_field_count = 1
 v8_typed_array_max_size_in_heap = 0

docs/api/web-contents.md

@@ -516,6 +516,15 @@ Emitted when the `WebContents` loses focus.
 
 Emitted when the `WebContents` gains focus.
 
+Note that on macOS, having focus means the `WebContents` is the first responder
+of window, so switching focus between windows would not trigger the `focus` and
+`blur` events of `WebContents`, as the first responder of each window is not
+changed.
+
+The `focus` and `blur` events of `WebContents` should only be used to detect
+focus change between different `WebContents` and `BrowserView` in the same
+window.
+
 #### Event: 'devtools-opened'
 
 Emitted when DevTools is opened.

docs/tutorial/electron-timelines.md

@@ -26,4 +26,5 @@ Special notes:
 | 14.0.0 | -- | 2021-May-27 | 2021-Aug-31 | M93 | v14.17 |
 | 15.0.0 | 2021-Jul-20 | 2021-Sep-01 | 2021-Sep-21 | M94 | v16.5 |
 | 16.0.0 | 2021-Sep-23 | 2021-Oct-20 | 2021-Nov-16 | M96 | v16.9 |
-| 17.0.0 | 2021-Nov-18 | 2022-Jan-06 | 2022-Feb-01 | M98 | TBD |
+| 17.0.0 | 2021-Nov-18 | 2022-Jan-06 | 2022-Feb-01 | M98 | v16.13 |
+| 18.0.0 | 2022-Feb-03 | 2022-Mar-03 | 2022-Mar-29 | M100 | TBD |

docs/tutorial/support.md

@@ -70,10 +70,10 @@ until the maintainers feel the maintenance burden is too high to continue doing
 
 ### Currently supported versions
 
+* 19.x.y
 * 18.x.y
 * 17.x.y
 * 16.x.y
-* 15.x.y
 
 ### End-of-life
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron",
-  "version": "18.0.0-nightly.20220201",
+  "version": "19.0.0-nightly.20220203",
   "repository": "https://github.com/electron/electron",
   "description": "Build cross platform desktop apps with JavaScript, HTML, and CSS",
   "devDependencies": {

shell/browser/native_window_views.cc

@@ -329,15 +329,14 @@ NativeWindowViews::NativeWindowViews(const gin_helper::Dictionary& options,
     // Set Window style so that we get a minimize and maximize animation when
     // frameless.
     DWORD frame_style = WS_CAPTION | WS_OVERLAPPED;
-    if (resizable_)
+    if (resizable_ && thick_frame_)
       frame_style |= WS_THICKFRAME;
     if (minimizable_)
       frame_style |= WS_MINIMIZEBOX;
     if (maximizable_)
       frame_style |= WS_MAXIMIZEBOX;
-    // We should not show a frame for transparent window.
-    if (!thick_frame_)
-      frame_style &= ~(WS_THICKFRAME | WS_CAPTION);
+    if (!thick_frame_ || !has_frame())
+      frame_style &= ~WS_CAPTION;
     ::SetWindowLong(GetAcceleratedWidget(), GWL_STYLE, frame_style);
   }
 

shell/browser/resources/win/electron.rc

@@ -50,8 +50,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 18,0,0,20220201
- PRODUCTVERSION 18,0,0,20220201
+ FILEVERSION 19,0,0,20220203
+ PRODUCTVERSION 19,0,0,20220203
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Electron"
-            VALUE "FileVersion", "18.0.0"
+            VALUE "FileVersion", "19.0.0"
             VALUE "InternalName", "electron.exe"
             VALUE "LegalCopyright", "Copyright (C) 2015 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "electron.exe"
             VALUE "ProductName", "Electron"
-            VALUE "ProductVersion", "18.0.0"
+            VALUE "ProductVersion", "19.0.0"
             VALUE "SquirrelAwareVersion", "1"
         END
     END

shell/browser/ui/win/electron_desktop_window_tree_host_win.cc

@@ -99,4 +99,21 @@ bool ElectronDesktopWindowTreeHostWin::GetClientAreaInsets(
   return false;
 }
 
+bool ElectronDesktopWindowTreeHostWin::HandleMouseEvent(ui::MouseEvent* event) {
+  // Call the default implementation of this method to get the event to its
+  // proper handler.
+  bool handled = views::DesktopWindowTreeHostWin::HandleMouseEvent(event);
+
+  // On WCO-enabled windows, we need to mark non-client mouse moved events as
+  // handled so they don't incorrectly propogate back to the OS.
+  if (native_window_view_->IsWindowControlsOverlayEnabled() &&
+      event->type() == ui::ET_MOUSE_MOVED &&
+      (event->flags() & ui::EF_IS_NON_CLIENT) != 0) {
+    event->SetHandled();
+    handled = true;
+  }
+
+  return handled;
+}
+
 }  // namespace electron

shell/browser/ui/win/electron_desktop_window_tree_host_win.h

@@ -36,6 +36,7 @@ class ElectronDesktopWindowTreeHostWin
   bool GetDwmFrameInsetsInPixels(gfx::Insets* insets) const override;
   bool GetClientAreaInsets(gfx::Insets* insets,
                            HMONITOR monitor) const override;
+  bool HandleMouseEvent(ui::MouseEvent* event) override;
 
  private:
   NativeWindowViews* native_window_view_;  // weak ref

shell/common/api/electron_api_native_image_mac.mm

@@ -10,8 +10,10 @@
 
 #import <Cocoa/Cocoa.h>
 #import <QuickLook/QuickLook.h>
+#import <QuickLookThumbnailing/QuickLookThumbnailing.h>
 
 #include "base/mac/foundation_util.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "gin/arguments.h"
 #include "shell/common/gin_converters/image_converter.h"
@@ -53,32 +55,81 @@ v8::Local<v8::Promise> NativeImage::CreateThumbnailFromPath(
   }
 
   CGSize cg_size = size.ToCGSize();
-  base::ScopedCFTypeRef<CFURLRef> cfurl = base::mac::FilePathToCFURL(path);
-  base::ScopedCFTypeRef<QLThumbnailRef> ql_thumbnail(
-      QLThumbnailCreate(kCFAllocatorDefault, cfurl, cg_size, NULL));
-  __block gin_helper::Promise<gfx::Image> p = std::move(promise);
-  // we do not want to blocking the main thread while waiting for quicklook to
-  // generate the thumbnail
-  QLThumbnailDispatchAsync(
-      ql_thumbnail,
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, /*flags*/ 0), ^{
-        base::ScopedCFTypeRef<CGImageRef> cg_thumbnail(
-            QLThumbnailCopyImage(ql_thumbnail));
-        if (cg_thumbnail) {
-          NSImage* result =
-              [[[NSImage alloc] initWithCGImage:cg_thumbnail
-                                           size:cg_size] autorelease];
-          gfx::Image thumbnail(result);
-          dispatch_async(dispatch_get_main_queue(), ^{
-            p.Resolve(thumbnail);
-          });
-        } else {
-          dispatch_async(dispatch_get_main_queue(), ^{
-            p.RejectWithErrorMessage("unable to retrieve thumbnail preview "
-                                     "image for the given path");
-          });
-        }
-      });
+
+  if (@available(macOS 10.15, *)) {
+    NSURL* nsurl = base::mac::FilePathToNSURL(path);
+
+    // We need to explicitly check if the user has passed an invalid path
+    // because QLThumbnailGenerationRequest will generate a stock file icon
+    // and pass silently if we do not.
+    if (![[NSFileManager defaultManager] fileExistsAtPath:[nsurl path]]) {
+      promise.RejectWithErrorMessage(
+          "unable to retrieve thumbnail preview image for the given path");
+      return handle;
+    }
+
+    NSScreen* screen = [[NSScreen screens] firstObject];
+    base::scoped_nsobject<QLThumbnailGenerationRequest> request(
+        [[QLThumbnailGenerationRequest alloc]
+              initWithFileAtURL:nsurl
+                           size:cg_size
+                          scale:[screen backingScaleFactor]
+            representationTypes:
+                QLThumbnailGenerationRequestRepresentationTypeAll]);
+    __block gin_helper::Promise<gfx::Image> p = std::move(promise);
+    [[QLThumbnailGenerator sharedGenerator]
+        generateBestRepresentationForRequest:request
+                           completionHandler:^(
+                               QLThumbnailRepresentation* thumbnail,
+                               NSError* error) {
+                             if (error || !thumbnail) {
+                               std::string err_msg(
+                                   [error.localizedDescription UTF8String]);
+                               dispatch_async(dispatch_get_main_queue(), ^{
+                                 p.RejectWithErrorMessage(
+                                     "unable to retrieve thumbnail preview "
+                                     "image for the given path: " +
+                                     err_msg);
+                               });
+                             } else {
+                               NSImage* result = [[[NSImage alloc]
+                                   initWithCGImage:[thumbnail CGImage]
+                                              size:cg_size] autorelease];
+                               gfx::Image image(result);
+                               dispatch_async(dispatch_get_main_queue(), ^{
+                                 p.Resolve(image);
+                               });
+                             }
+                           }];
+  } else {
+    base::ScopedCFTypeRef<CFURLRef> cfurl = base::mac::FilePathToCFURL(path);
+    base::ScopedCFTypeRef<QLThumbnailRef> ql_thumbnail(
+        QLThumbnailCreate(kCFAllocatorDefault, cfurl, cg_size, NULL));
+    __block gin_helper::Promise<gfx::Image> p = std::move(promise);
+    // Do not block the main thread waiting for quicklook to generate the
+    // thumbnail.
+    QLThumbnailDispatchAsync(
+        ql_thumbnail,
+        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, /*flags*/ 0), ^{
+          base::ScopedCFTypeRef<CGImageRef> cg_thumbnail(
+              QLThumbnailCopyImage(ql_thumbnail));
+          if (cg_thumbnail) {
+            NSImage* result =
+                [[[NSImage alloc] initWithCGImage:cg_thumbnail
+                                             size:cg_size] autorelease];
+            gfx::Image thumbnail(result);
+            dispatch_async(dispatch_get_main_queue(), ^{
+              p.Resolve(thumbnail);
+            });
+          } else {
+            dispatch_async(dispatch_get_main_queue(), ^{
+              p.RejectWithErrorMessage("unable to retrieve thumbnail preview "
+                                       "image for the given path");
+            });
+          }
+        });
+  }
+
   return handle;
 }
 

spec-main/api-web-contents-spec.ts

@@ -826,15 +826,20 @@ describe('webContents module', () => {
       });
     });
 
+    const moveFocusToDevTools = async (win: BrowserWindow) => {
+      const devToolsOpened = emittedOnce(win.webContents, 'devtools-opened');
+      win.webContents.openDevTools({ mode: 'right' });
+      await devToolsOpened;
+      win.webContents.devToolsWebContents!.focus();
+    };
+
     describe('focus event', () => {
       afterEach(closeAllWindows);
+
       it('is triggered when web contents is focused', async () => {
         const w = new BrowserWindow({ show: false });
         await w.loadURL('about:blank');
-        const devToolsOpened = emittedOnce(w.webContents, 'devtools-opened');
-        w.webContents.openDevTools();
-        await devToolsOpened;
-        w.webContents.devToolsWebContents!.focus();
+        await moveFocusToDevTools(w);
         const focusPromise = emittedOnce(w.webContents, 'focus');
         w.webContents.focus();
         await expect(focusPromise).to.eventually.be.fulfilled();
@@ -849,16 +854,17 @@ describe('webContents module', () => {
           window2.loadURL('about:blank')
         ]);
 
+        const focusPromise1 = emittedOnce(window1.webContents, 'focus');
+        const focusPromise2 = emittedOnce(window2.webContents, 'focus');
+
         window1.showInactive();
         window2.showInactive();
 
-        let focusPromise = emittedOnce(window1.webContents, 'focus');
         window1.focus();
-        await expect(focusPromise).to.eventually.be.fulfilled();
+        await expect(focusPromise1).to.eventually.be.fulfilled();
 
-        focusPromise = emittedOnce(window2.webContents, 'focus');
         window2.focus();
-        await expect(focusPromise).to.eventually.be.fulfilled();
+        await expect(focusPromise2).to.eventually.be.fulfilled();
       });
     });
 
@@ -867,11 +873,9 @@ describe('webContents module', () => {
       it('is triggered when web contents is blurred', async () => {
         const w = new BrowserWindow({ show: true });
         await w.loadURL('about:blank');
+        w.webContents.focus();
         const blurPromise = emittedOnce(w.webContents, 'blur');
-        const devToolsOpened = emittedOnce(w.webContents, 'devtools-opened');
-        w.webContents.openDevTools({ mode: 'detach' });
-        await devToolsOpened;
-        w.webContents.devToolsWebContents!.focus();
+        await moveFocusToDevTools(w);
         await expect(blurPromise).to.eventually.be.fulfilled();
       });
     });