BrowserWebContentsDelegate was split from Browser in recent
refactoring and can now be extended instead of patched. This
change is strictly structural.
Exclude Chrome UI contents using WebUIContentsPreloadState. These
contents have no owning CefBrowserHost, so allow excluded requests
to complete without browser info instead of waiting for a timeout.
ChromeBrowserWidget closes owned widgets before the parent WindowClosing
callback can detach overlay contents. Closing an overlay widget with
CloseNow therefore deletes its contents View and invalidates the CefView
retained by the client.
Extract CefWindowView::CloseOverlayViews and call it from both
WindowClosing and ChromeBrowserWidget::CloseOwnedWidgets. This detaches
overlay contents and restores CEF ownership before owned widgets are
destroyed. Direct overlay widget closure retains its destruction behavior,
which Alloy overlay browsers need to complete browser shutdown.
Add an explicit IsValid assertion to the overlay destruction tests.
To test:
ceftests --gtest_filter=ChromeChildWindowTest.*:OwnedWidgetShutdownTest.*:ViewsBrowserViewTest.*
Browser closure and native window destruction may occur in either order.
Subscribe ChromeBrowserWidget to BrowserDidClose so owned widgets are closed
synchronously before the Browser deletion task is posted. Retain the existing
OnNativeWidgetDestroying cleanup for the reverse ordering.
This prevents password and other Browser-owned bubbles from dereferencing
Browser state after it has been destroyed.
Keep CEF-created unique OTR profiles when resolving the DevTools
profile so Inspect Element does not create the popup with the parent
profile. Add coverage for a non-global request context and verify that
the DevTools popup shares it.
Close widgets owned by ChromeBrowserWidget from
OnNativeWidgetDestroying while the native ownership graph is still
available. This prevents popup widgets from outliving Browser state during
native-window-driven shutdown.
Add Chrome-style ceftests for JavaScript, password-save, and synthetic owned
widgets. Confirm that each widget exists before closing the main window and
verify deterministic destruction ordering for the synthetic case. Reset the
password dismissal statistics before loading the password form so repeated
test runs continue to exercise the save-password widget.
BrowserContext cleanup can delete proxy factories while URL loaders
are still active, leaving request handler state populated during
destruction.
Add a shutdown hook that reuses the existing cancellation path
before erasing proxies. Handle pending initialization and repeated
shutdown safely.
Guard the owning-window lookup in FileSelectHelper::RunFileChooserOnUIThread.
Add ceftests DialogTest.FileInputOSR test for triggering and canceling a file
input in OSR mode.
`wWinMain` is the wide-character entry point -- `lpCmdLine` is always
`wchar_t*`. Using `LPTSTR` (a TCHAR-mapped type) creates a type mismatch
at the DLL boundary when client DLLs are built without `UNICODE`
defined.
Two Chromium changes in M145 broke CefPrintHandler on Linux. Print
dialog creation moved to PrintingContextLinux::PrintDialogFactory,
whose default implementation bypasses CEF's printing delegate. Dialog
ownership also changed to std::unique_ptr.
Register a CEF factory that routes browsers with a CefPrintHandler
through CefPrintingContextLinuxDelegate while preserving Chromium's
default behavior for other browsers.
Use a unique_ptr-owned proxy around the reference-counted
CefPrintDialogLinux so asynchronous print jobs can outlive their
PrintingContext.
As with #3729, out-of-process printing must be disabled
(--disable-features=EnableOopPrintDrivers) for the callbacks to fire.
Chrome-style browsers with a native parent use TYPE_CONTROL widgets,
which have no NonClientView, so client_view() returns nullptr. Guard
that InvalidateLayout call; the earlier non_client_view() check alone
was insufficient.
Replace cefclient's separate launch-health and update timers with a single
health-first task. Start the update only after launch_success returns structured
success so the running version becomes a confirmed fallback before a newer
version is installed.
Keep older confirmed launch records until the selected version's health is
durably confirmed. A normal exit remains neutral in explicit mode, while
exit-code and health-off modes retain their clean-exit pruning behavior.
Reconcile valid indexes under the installer lock by quarantining canonical
version directories absent from the index. Defer loaded-DLL cleanup through
.trash for later writers, and avoid emergency-recovery warnings for an empty
fresh store while preserving warnings for meaningful recovery attempts.
Expand unit and Windows E2E coverage for update ordering, confirmation and
persistence failures, fallback retention, pruning modes, loaded-version
quarantine, lock contention, and recovery. Update the installer documentation
to describe the combined behavior.
New behavior confirmed with cefclient:
1. Launch cefclient. After 60 seconds, 'launch_success' confirms the old
version and 'update' installs the new version.
2. Exit and relaunch cefclient. Second run uses the new version. After 60
seconds, 'launch_success' confirms the new version. Upon clean exit the
old version loses fallback protection and is pruned.
Avoid tempfile.NamedTemporaryFile's effectively unbounded Windows retry.
Restricted sandboxes can deny YAPF grammar-cache writes. Write each cache
to a unique file, close it, and atomically replace it. Clean up failures
to prevent orphaned pickle files.
Upstream issue: https://github.com/google/yapf/issues/1311
Clear the parser notification context in a finally block for both CppToC
and CToCpp implementation writers, including when generation raises.
Update failure-path regressions to require context restoration while
preserving successful output behavior.
Merge generated and manually maintained GYPI variables with copy and update
so the CLI works on Python 3 while preserving manual override precedence.
Add a hermetic CLI regression for exact output, progress diagnostics, and
unchanged repeated generation.
Unpack the CppToC and CToCpp generator results before writing generated
content to stdout. This preserves the existing generator return contracts.
Add successful CLI regressions that verify exact output, empty stderr, and
unchanged input files.
Return a nonzero status when distribution option validation fails so callers
do not interpret rejected invocations as successful.
Replace the existing characterization with regressions that verify the status,
diagnostics, and absence of partial output artifacts.
Return the combined header and include write result from make_pack_header.
This ensures callers observe repairs that modify only the generated include.
Replace the existing bug characterization with a regression test for the
correct return contract. Generated file contents remain unchanged.
Add deterministic fixtures, goldens, and matching tests for all 18
make_* generators. Refactor make_distrib orchestration behind an
importable main entry point while preserving generated output. Add
passing characterizations for existing generator issues.
Add tools for analyzing code coverage of CEF installer tests:
- analyze_coverage_output.py: Parse llvm-cov JSON summaries, filter by
path, and report uncovered functions and line ranges.
- CLAUDE_COVERAGE_INSTRUCTIONS.md: One-time setup and usage guide for
generating coverage reports with llvm-profdata/llvm-cov.
- Unit tests for the analysis script.
When building a client DLL loaded by bootstrap.exe, default to the last
released API version instead of the experimental (unversioned) API. The
experimental API is not back/forward compatible across CEF versions and
does not bump the version number, so the installer's vmin-based version
selection cannot work safely against it. Building with
CEF_API_VERSION=CEF_API_VERSION_LAST makes the client forward-compatible
with newer libcef.dll binaries (via API backwards compatibility).
Add a shared CEF installer that downloads, verifies, and manages CEF
binary distributions on Windows. The installer is embedded in
application bootstrap binaries and resolves the correct CEF version
from a CDN manifest based on each application's version and ABI
compatibility requirements.
Key components:
- CDN manifest parsing and version resolution
- WinHTTP-based download with SHA-1/SHA-256 integrity verification
- Authenticode catalog (.cat) signature verification
- Parallel XZ decompression for fast archive extraction
- Per-version metadata (cef_version.json) with full version tracking
- Shared installation database for multi-app version management
- Version pruning to reclaim disk space from unused versions
- Revocation list support (compiled-in baseline + CDN delta)
- Progress UI with WM_COPYDATA-based cancellation
- Bundled CEF fallback for offline/CDN-failure scenarios
Add cef_installer_builder.py to generate per-milestone and per-platform
JSON manifests consumed by the CEF bootstrap installer. Extend
cef_json_builder.py with abi_hash, signed archive tracking, and
revocation list (revoked.json) support. Includes unit tests.
Allow size-prefixed structures passed by newer libcef versions to exceed
the client wrapper's local structure size. The wrapper already limits
copies to known fields, so rejecting larger structures breaks API forward
compatibility.
Add coverage using an older wrapper view of a newer structure.
Marshall Greenblatt