Fix macOS ARM64 compilation errors in macOS message loop and CMake

main_message_loop_external_pump_mac.mm: update from old Chromium idioms
to modern C++/CEF 146 API:
- Replace OVERRIDE macro with C++11 override keyword
- Replace int64 with int64_t to match base class signatures (prevents
  vtable mismatch / override not recognized by compiler)
- Replace scoped_ptr<>/new with std::unique_ptr/std::make_unique in
  Create() (scoped_ptr is no longer defined in CEF 146)
- Fix NSNumber truncation: numberWithInt(int64_t) -> numberWithLongLong
  and integerValue -> longLongValue to preserve full 64-bit range
- Add #if !__has_feature(objc_arc) guards around retain/release calls
  for ARC compatibility; nil out pointers in destructor

CMakeLists.txt / src/subprocess/CMakeLists.txt: use
-mmacosx-version-min=11.0 on arm64 (Apple Silicon requires macOS 11+;
using 10.9 with -arch arm64 is rejected by the Apple linker)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: linesight

CMakeLists.txt

@@ -218,8 +218,13 @@ elseif(APPLE)
         BROWSER_PROCESS
         CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
     )
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+        set(_macos_ver_min 11.0)
+    else()
+        set(_macos_ver_min 10.9)
+    endif()
     target_link_options(${MODULE_NAME} PRIVATE
-        -mmacosx-version-min=10.9
+        -mmacosx-version-min=${_macos_ver_min}
         -Wl,-search_paths_first -Wl,-dead_strip
         "-F${CEF_ROOT}/bin" "-framework" "Chromium Embedded Framework"
         "-Wl,-rpath,@loader_path/"

src/subprocess/CMakeLists.txt

@@ -135,11 +135,16 @@ if(WIN32)
         /MANIFEST:NO /LARGEADDRESSAWARE /SUBSYSTEM:WINDOWS
     )
 elseif(APPLE)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+        set(_macos_ver_min 11.0)
+    else()
+        set(_macos_ver_min 10.9)
+    endif()
     target_compile_options(cefpython_subprocess PRIVATE -DNDEBUG -O3)
     target_compile_definitions(cefpython_subprocess PRIVATE
         CEFPYTHON_API_H_FILE="cefpython_api_fixed.h")
     target_link_options(cefpython_subprocess PRIVATE
-        -mmacosx-version-min=10.9
+        -mmacosx-version-min=${_macos_ver_min}
         "-F${CEFPYTHON_CEF_ROOT}/bin"
         "-framework" "Chromium Embedded Framework"
     )

src/subprocess/main_message_loop/main_message_loop_external_pump_mac.mm

@@ -4,8 +4,10 @@
 
 #include "main_message_loop_external_pump.h"
 
-#import <Foundation/Foundation.h>
 #import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+
+#include <memory>
 
 #include "include/cef_app.h"
 
@@ -17,22 +19,22 @@
   ~MainMessageLoopExternalPumpMac();
 
   // MainMessageLoopStd methods:
-  void Quit() OVERRIDE;
-  int Run() OVERRIDE;
+  void Quit() override;
+  int Run() override;
 
   // MainMessageLoopExternalPump methods:
-  void OnScheduleMessagePumpWork(int64 delay_ms) OVERRIDE;
+  void OnScheduleMessagePumpWork(int64_t delay_ms) override;
 
   // Internal methods used for processing the event callbacks. They are public
   // for simplicity but should not be used directly.
-  void HandleScheduleWork(int64 delay_ms);
+  void HandleScheduleWork(int64_t delay_ms);
   void HandleTimerTimeout();
 
  protected:
   // MainMessageLoopExternalPump methods:
-  void SetTimer(int64 delay_ms) OVERRIDE;
-  void KillTimer() OVERRIDE;
-  bool IsTimerPending() OVERRIDE { return timer_ != nil; }
+  void SetTimer(int64_t delay_ms) override;
+  void KillTimer() override;
+  bool IsTimerPending() override { return timer_ != nil; }
 
  private:
   // Owner thread that will run events.
@@ -66,7 +68,7 @@ - (id)initWithPump:(MainMessageLoopExternalPumpMac*)pump {
 }
 
 - (void)scheduleWork:(NSNumber*)delay_ms {
-  pump_->HandleScheduleWork([delay_ms integerValue]);
+  pump_->HandleScheduleWork([delay_ms longLongValue]);
 }
 
 - (void)timerTimeout:(id)obj {
@@ -76,15 +78,21 @@ - (void)timerTimeout:(id)obj {
 @end
 
 MainMessageLoopExternalPumpMac::MainMessageLoopExternalPumpMac()
-  : owner_thread_([[NSThread currentThread] retain]),
-    timer_(nil) {
-  event_handler_ = [[[EventHandler alloc] initWithPump:this] retain];
+    : owner_thread_([NSThread currentThread]), timer_(nil) {
+#if !__has_feature(objc_arc)
+  [owner_thread_ retain];
+#endif
+  event_handler_ = [[EventHandler alloc] initWithPump:this];
 }
 
 MainMessageLoopExternalPumpMac::~MainMessageLoopExternalPumpMac() {
   KillTimer();
+#if !__has_feature(objc_arc)
   [owner_thread_ release];
   [event_handler_ release];
+#endif
+  owner_thread_ = nil;
+  event_handler_ = nil;
 }
 
 void MainMessageLoopExternalPumpMac::Quit() {
@@ -106,59 +114,64 @@ - (void)timerTimeout:(id)obj {
 
     // Do some work.
     CefDoMessageLoopWork();
-    
+
     // Sleep to allow the CEF proc to do work.
     [NSThread sleepForTimeInterval: 0.05];
   }
 
   return 0;
 }
 
-void MainMessageLoopExternalPumpMac::OnScheduleMessagePumpWork(int64 delay_ms) {
+void MainMessageLoopExternalPumpMac::OnScheduleMessagePumpWork(
+    int64_t delay_ms) {
   // This method may be called on any thread.
-  NSNumber* number = [NSNumber numberWithInt:static_cast<int>(delay_ms)];
+  NSNumber* number = [NSNumber numberWithLongLong:delay_ms];
   [event_handler_ performSelector:@selector(scheduleWork:)
                          onThread:owner_thread_
                        withObject:number
                     waitUntilDone:NO];
 }
 
-void MainMessageLoopExternalPumpMac::HandleScheduleWork(int64 delay_ms) {
+void MainMessageLoopExternalPumpMac::HandleScheduleWork(int64_t delay_ms) {
   OnScheduleWork(delay_ms);
 }
 
 void MainMessageLoopExternalPumpMac::HandleTimerTimeout() {
   OnTimerTimeout();
 }
 
-void MainMessageLoopExternalPumpMac::SetTimer(int64 delay_ms) {
+void MainMessageLoopExternalPumpMac::SetTimer(int64_t delay_ms) {
   DCHECK_GT(delay_ms, 0);
   DCHECK(!timer_);
 
   const double delay_s = static_cast<double>(delay_ms) / 1000.0;
-  timer_ = [[NSTimer timerWithTimeInterval: delay_s
-                                    target: event_handler_
-                                  selector: @selector(timerTimeout:)
-                                  userInfo: nil
-                                   repeats: NO] retain];
+  timer_ = [NSTimer timerWithTimeInterval:delay_s
+                                   target:event_handler_
+                                 selector:@selector(timerTimeout:)
+                                 userInfo:nil
+                                  repeats:NO];
+#if !__has_feature(objc_arc)
+  [timer_ retain];
+#endif
 
   // Add the timer to default and tracking runloop modes.
   NSRunLoop* owner_runloop = [NSRunLoop currentRunLoop];
-  [owner_runloop addTimer: timer_ forMode: NSRunLoopCommonModes];
-  [owner_runloop addTimer: timer_ forMode: NSEventTrackingRunLoopMode];
+  [owner_runloop addTimer:timer_ forMode:NSRunLoopCommonModes];
+  [owner_runloop addTimer:timer_ forMode:NSEventTrackingRunLoopMode];
 }
 
 void MainMessageLoopExternalPumpMac::KillTimer() {
   if (timer_ != nil) {
     [timer_ invalidate];
+#if !__has_feature(objc_arc)
     [timer_ release];
+#endif
     timer_ = nil;
   }
 }
 
 // static
-scoped_ptr<MainMessageLoopExternalPump>
+std::unique_ptr<MainMessageLoopExternalPump>
 MainMessageLoopExternalPump::Create() {
-  return scoped_ptr<MainMessageLoopExternalPump>(
-      new MainMessageLoopExternalPumpMac());
+  return std::make_unique<MainMessageLoopExternalPumpMac>();
 }