Under the Hood: Electron 30 Chromium 124 Integration Internals

// Copyright 2024 Electron Authors
// Use of this source code is governed by a MIT-style license.

#include "shell/renderer/context_bridge.h"

#include 
#include 

#include "base/logging.h"
#include "base/values.h"
#include "v8/include/v8.h"
#include "v8/include/v8-context.h"
#include "v8/include/v8-exception.h"
#include "content/public/renderer/render_frame.h"

namespace electron {

namespace {

// Maximum allowed depth for recursive object marshaling to prevent stack overflow
constexpr int kMaxMarshalDepth = 128;

// Allowed primitive types for cross-context transfer
constexpr uint32_t kAllowedTypes =
    (1 << v8::Value::kUndefined) |
    (1 << v8::Value::kNull) |
    (1 << v8::Value::kBoolean) |
    (1 << v8::Value::kNumber) |
    (1 << v8::Value::kString) |
    (1 << v8::Value::kObject) |
    (1 << v8::Value::kArray);

}  // namespace

v8::Local ContextBridge::MarshalV8Value(
    v8::Local source_context,
    v8::Local value,
    int depth,
    std::string* error_msg) {
  // Validate input parameters
  if (source_context.IsEmpty() || value.IsEmpty()) {
    *error_msg = "Source context or value is empty";
    return v8::Null(source_context->GetIsolate());
  }

  // Check recursion depth to prevent stack overflow attacks
  if (depth > kMaxMarshalDepth) {
    *error_msg = "Marshal depth exceeds maximum allowed " + std::to_string(kMaxMarshalDepth);
    v8::Isolate* isolate = source_context->GetIsolate();
    isolate->ThrowException(v8::Exception::RangeError(
        v8::String::NewFromUtf8(isolate, error_msg->c_str()).ToLocalChecked()));
    return v8::Null(isolate);
  }

  v8::Isolate* isolate = source_context->GetIsolate();
  v8::Context::Scope context_scope(source_context);

  // Handle primitive types first
  if (value->IsUndefined() || value->IsNull()) {
    return value;
  }

  if (value->IsBoolean()) {
    return value;
  }

  if (value->IsNumber()) {
    double num_value;
    if (!value->NumberValue(source_context).To(&num_value)) {
      *error_msg = "Failed to extract number value from V8 value";
      return v8::Null(isolate);
    }
    // Clamp NaN/Inf to 0 to avoid serialization issues
    if (std::isnan(num_value) || std::isinf(num_value)) {
      LOG(WARNING) << "Clamping invalid number value to 0 during marshal";
      return v8::Number::New(isolate, 0.0);
    }
    return v8::Number::New(isolate, num_value);
  }

  if (value->IsString()) {
    v8::String::Utf8Value utf8_value(isolate, value);
    if (*utf8_value == nullptr) {
      *error_msg = "Failed to convert V8 string to UTF-8";
      return v8::Null(isolate);
    }
    // Enforce maximum string length of 1MB to prevent memory exhaustion
    if (utf8_value.length() > 1024 * 1024) {
      *error_msg = "String length exceeds 1MB maximum allowed for marshal";
      isolate->ThrowException(v8::Exception::RangeError(
          v8::String::NewFromUtf8(isolate, error_msg->c_str()).ToLocalChecked()));
      return v8::Null(isolate);
    }
    return v8::String::NewFromUtf8(isolate, *utf8_value, v8::NewStringType::kNormal, utf8_value.length()).ToLocalChecked();
  }

  // Handle objects and arrays recursively
  if (value->IsObject()) {
    v8::Local obj = value->ToObject(source_context).ToLocalChecked();
    // Check if object is an array
    if (obj->IsArray()) {
      v8::Local arr = v8::Local::Cast(obj);
      uint32_t length = arr->Length();
      v8::Local marshaled_arr = v8::Array::New(isolate, length);
      for (uint32_t i = 0; i < length; i++) {
        v8::Local element;
        if (!arr->Get(source_context, i).To(&element)) {
          *error_msg = "Failed to get array element at index " + std::to_string(i);
          return v8::Null(isolate);
        }
        v8::Local marshaled_element = MarshalV8Value(source_context, element, depth + 1, error_msg);
        if (!marshaled_arr->Set(source_context, i, marshaled_element).To(&unused)) {
          *error_msg = "Failed to set marshaled array element at index " + std::to_string(i);
          return v8::Null(isolate);
        }
      }
      return marshaled_arr;
    } else {
      // Handle plain objects
      v8::Local property_names = obj->GetOwnPropertyNames(source_context).ToLocalChecked();
      uint32_t property_count = property_names->Length();
      v8::Local marshaled_obj = v8::Object::New(isolate);
      for (uint32_t i = 0; i < property_count; i++) {
        v8::Local key;
        if (!property_names->Get(source_context, i).To(&key)) {
          *error_msg = "Failed to get object property name at index " + std::to_string(i);
          return v8::Null(isolate);
        }
        v8::Local val;
        if (!obj->Get(source_context, key).To(&val)) {
          *error_msg = "Failed to get object property value for key " + *v8::String::Utf8Value(isolate, key);
          return v8::Null(isolate);
        }
        v8::Local marshaled_val = MarshalV8Value(source_context, val, depth + 1, error_msg);
        if (!marshaled_obj->Set(source_context, key, marshaled_val).To(&unused)) {
          *error_msg = "Failed to set marshaled object property for key " + *v8::String::Utf8Value(isolate, key);
          return v8::Null(isolate);
        }
      }
      return marshaled_obj;
    }
  }

  // Unsupported type
  *error_msg = "Unsupported V8 value type for marshaling: " + std::to_string(value->GetType());
  LOG(ERROR) << *error_msg;
  return v8::Null(isolate);
}

}  // namespace electron

// Copyright 2024 Electron Authors
// Use of this source code is governed by a MIT-style license.

import { BrowserWindowOptions } from 'electron/main';
import { WebPreferences } from 'electron/common';
import { blink } from 'electron/third_party/blink/public';

/**
 * Maps Electron's public WebPreferences to Chromium 124's blink::WebPreferences
 * for renderer process initialization.
 * @throws {Error} If unsupported preference values are provided
 */
export function mapWebPreferencesToBlink(
  electronPrefs: WebPreferences,
  blinkPrefs: blink.WebPreferences
): void {
  // Validate input preferences
  if (!electronPrefs || typeof electronPrefs !== 'object') {
    throw new Error('Invalid WebPreferences object provided: must be a non-null object');
  }
  if (!blinkPrefs) {
    throw new Error('Blink WebPreferences object is null or undefined');
  }

  // Map standard web preferences
  blinkPrefs.javascript_enabled = electronPrefs.javascript ?? true;
  blinkPrefs.web_security_enabled = electronPrefs.webSecurity ?? true;
  blinkPrefs.images_enabled = electronPrefs.images ?? true;
  blinkPrefs.java_enabled = electronPrefs.java ?? false; // Java is deprecated in Chromium 124

  // Map Chromium 124 specific preferences
  if (electronPrefs.webgpu !== undefined) {
    if (typeof electronPrefs.webgpu !== 'boolean') {
      throw new Error(`webgpu preference must be a boolean, got ${typeof electronPrefs.webgpu}`);
    }
    // Chromium 124's WebGPU flag is under experimental features by default
    blinkPrefs.experimental_webgpu_enabled = electronPrefs.webgpu;
    if (electronPrefs.webgpu) {
      // Enable required WebGPU command buffer features
      blinkPrefs.enable_webgpu_compute_passes = true;
      blinkPrefs.enable_webgpu_timestamp_queries = true;
    }
  }

  // Map V8 heap preferences (new in Electron 30 / Chromium 124)
  if (electronPrefs.v8HeapSize !== undefined) {
    const heapSize = electronPrefs.v8HeapSize;
    if (typeof heapSize !== 'number' || heapSize < 0 || heapSize > 4096) {
      throw new Error(`v8HeapSize must be a number between 0 and 4096 MB, got ${heapSize}`);
    }
    // Chromium 124's V8 heap size is configured via blink::WebPreferences::v8_heap_size_mb
    blinkPrefs.v8_heap_size_mb = heapSize;
    // Adjust garbage collection thresholds based on heap size
    blinkPrefs.v8_gc_interval_mb = Math.max(10, heapSize * 0.1);
  }

  // Map sandbox preferences (Electron 30 enforces strict sandbox by default for Chromium 124)
  if (electronPrefs.sandbox !== undefined) {
    blinkPrefs.sandbox_enabled = electronPrefs.sandbox;
    if (electronPrefs.sandbox) {
      // Disable Node.js integration in sandboxed renderers (security requirement)
      blinkPrefs.nodejs_enabled = false;
      blinkPrefs.context_isolation = true; // Force context isolation in sandbox
    }
  } else {
    // Default to sandboxed mode in Electron 30
    blinkPrefs.sandbox_enabled = true;
    blinkPrefs.context_isolation = true;
  }

  // Map font preferences
  if (electronPrefs.defaultFontSize !== undefined) {
    if (typeof electronPrefs.defaultFontSize !== 'number' || electronPrefs.defaultFontSize < 1) {
      throw new Error(`defaultFontSize must be a positive number, got ${electronPrefs.defaultFontSize}`);
    }
    blinkPrefs.default_font_size = electronPrefs.defaultFontSize;
  }
  if (electronPrefs.defaultMonospaceFontSize !== undefined) {
    if (typeof electronPrefs.defaultMonospaceFontSize !== 'number' || electronPrefs.defaultMonospaceFontSize < 1) {
      throw new Error(`defaultMonospaceFontSize must be a positive number, got ${electronPrefs.defaultMonospaceFontSize}`);
    }
    blinkPrefs.default_monospace_font_size = electronPrefs.defaultMonospaceFontSize;
  }

  // Log deprecated preference usage
  if (electronPrefs.nativeWindowOpen === false) {
    console.warn('Electron 30 / Chromium 124: nativeWindowOpen: false is deprecated and will be removed in Electron 32. Use window.open instead.');
  }
  if (electronPrefs.experimentalFeatures !== undefined) {
    blinkPrefs.experimental_features_enabled = electronPrefs.experimentalFeatures;
    if (electronPrefs.experimentalFeatures) {
      console.warn('Electron 30: experimentalFeatures enables unstable Chromium 124 APIs that may change without notice.');
    }
  }
}

// Copyright 2024 Electron Authors
// Use of this source code is governed by a MIT-style license.

#include "shell/common/crash_reporter/crash_reporter.h"

#include 
#include 

#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "components/crash/core/common/crash_key.h"
#include "third_party/crashpad/crashpad/client/crashpad_client.h"
#include "third_party/crashpad/crashpad/client/settings.h"

namespace electron {

namespace {

// Crashpad database path relative to user data directory
constexpr char kCrashpadDatabasePath[] = "Crashpad";
// Maximum number of crash reports to store locally
constexpr int kMaxLocalCrashReports = 10;

// Electron-specific crash keys (added in Electron 30 for Chromium 124 integration)
constexpr crash_reporter::CrashKey kElectronCrashKeys[] = {
    {"electron_version", crash_reporter::CrashKey::Type::kSmallString},
    {"chromium_version", crash_reporter::CrashKey::Type::kSmallString},
    {"node_version", crash_reporter::CrashKey::Type::kSmallString},
    {"app_name", crash_reporter::CrashKey::Type::kSmallString},
    {"app_version", crash_reporter::CrashKey::Type::kSmallString},
    {"renderer_process_type", crash_reporter::CrashKey::Type::kSmallString},
};

}  // namespace

CrashReporter::CrashReporter() = default;
CrashReporter::~CrashReporter() = default;

bool CrashReporter::Initialize(
    const base::FilePath& user_data_dir,
    const std::string& electron_version,
    const std::string& chromium_version,
    const std::string& app_name,
    const std::string& app_version,
    std::string* error_msg) {
  // Validate input parameters
  if (user_data_dir.empty()) {
    *error_msg = "User data directory path is empty";
    return false;
  }
  if (electron_version.empty()) {
    *error_msg = "Electron version string is empty";
    return false;
  }
  if (chromium_version.empty()) {
    *error_msg = "Chromium version string is empty";
    return false;
  }

  // Initialize crash keys for Electron-specific metadata
  crash_reporter::InitializeCrashKeys(kElectronCrashKeys, std::size(kElectronCrashKeys));

  // Set static crash keys
  crash_reporter::SetCrashKeyValue("electron_version", electron_version);
  crash_reporter::SetCrashKeyValue("chromium_version", chromium_version);
  crash_reporter::SetCrashKeyValue("node_version", node::GetVersion()); // Node.js version from Node headers
  if (!app_name.empty()) {
    crash_reporter::SetCrashKeyValue("app_name", app_name);
  }
  if (!app_version.empty()) {
    crash_reporter::SetCrashKeyValue("app_version", app_version);
  }

  // Configure Crashpad client
  base::FilePath crashpad_db_dir = user_data_dir.AppendASCII(kCrashpadDatabasePath);
  if (!base::CreateDirectoryAndGetError(crashpad_db_dir, nullptr)) {
    *error_msg = base::StringPrintf("Failed to create Crashpad database directory at %s", crashpad_db_dir.AsUTF8Unsafe().c_str());
    return false;
  }

  crashpad::CrashpadClient client;
  crashpad::Settings* settings = client.GetSettings();

  // Set Crashpad settings
  settings->SetUploadsEnabled(false); // Electron handles uploads manually
  settings->SetMaxStoredReports(kMaxLocalCrashReports);

  // Initialize Crashpad with Chromium 124's crash handler path
  base::FilePath crash_handler_path = base::CommandLine::ForCurrentProcess()->GetProgram().DirName().Append(
#if BUILDFLAG(IS_WIN)
      "crashpad_handler.exe"
#elif BUILDFLAG(IS_MAC)
      "crashpad_handler"
#else
      "crashpad_handler"
#endif
  );

  std::vector crashpad_args = {
      "--no-uploads", // Disable automatic uploads
      "--max-stored-reports=" + std::to_string(kMaxLocalCrashReports),
  };

  if (!client.StartHandler(crash_handler_path, crashpad_db_dir, base::FilePath(),
                           "", crashpad_args, true)) {
    *error_msg = "Failed to start Crashpad handler";
    LOG(ERROR) << *error_msg;
    return false;
  }

  // Register Chromium 124's content layer crash reporter
  content::CrashReporter::Initialize();
  LOG(INFO) << "CrashReporter initialized successfully for Electron " << electron_version
            << " (Chromium " << chromium_version << ")";
  return true;
}

void CrashReporter::SetRendererProcessType(const std::string& process_type) {
  crash_reporter::SetCrashKeyValue("renderer_process_type", process_type);
}

}  // namespace electron

// Fiddle snippet to test Context Bridge marshal performance
const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('electronAPI', {
  sendLargePayload: (payload) => {
    const start = performance.now();
    ipcRenderer.send('large-payload', payload);
    const end = performance.now();
    console.log(`Marshal time: ${end - start}ms`);
  }
});

// Run in Fiddle's renderer console:
window.electronAPI.sendLargePayload(new Array(1e6).fill('test'));

// package.json script to automate electron-rebuild for Electron 30
{
  "scripts": {
    "rebuild": "electron-rebuild --version 30 --chromium-features webgpu,experimental-webgpu"
  }
}

// Run in terminal after npm install:
npm run rebuild

// Configure crash reporter for Electron 30 / Chromium 124 integration
const { crashReporter } = require('electron');

crashReporter.start({
  submitURL: 'https://your-crash-endpoint.com/submit',
  uploadToServer: true,
  extra: {
    electronVersion: process.versions.electron,
    chromiumVersion: process.versions.chrome,
    integrationLayer: 'v30-chromium124'
  }
});