diff --git a/README.md b/README.md index 2dc42bf..fbd0504 100644 --- a/README.md +++ b/README.md @@ -33,10 +33,14 @@ page. Streams carry video only. `ChromiumPage.isCapturingDisplay` and (stop-all) now ends them too. Without Chromium's macOS picker, display requests are refused before the host is asked. Window management (`getScreenDetails`) arrives as `.windowManagement` and accepts `allow()` or `deny()`. Set -`ChromiumContext.permissionResolver` to answer status checks, including quiet -checks on load, from saved decisions. Chromium keeps only a session grant for -unsaved answers and stores no denial; -`ChromiumContext.resetPermission(.windowManagement, origin:)` clears it. Other +`ChromiumContext.permissionResolver` to answer camera, microphone and +window-management status checks from saved decisions, including quiet checks +on load, `permissions.query` and whether `enumerateDevices` names devices. +Chromium keeps only a session grant for unsaved answers and stores no denial. +An allowed camera or microphone request leaves a one-time grant for the +top-level origin, so sites can list and pick devices; +`ChromiumContext.resetPermission(_:origin:)` clears `.camera`, `.microphone` and +`.windowManagement` grants. Other prompt-backed permissions stay denied. This client requires a rebuilt ABI 19 runtime. diff --git a/Sources/ChromiumHarness/ChromiumHarnessValidation.swift b/Sources/ChromiumHarness/ChromiumHarnessValidation.swift index 65eacea..533fc71 100644 --- a/Sources/ChromiumHarness/ChromiumHarnessValidation.swift +++ b/Sources/ChromiumHarness/ChromiumHarnessValidation.swift @@ -874,6 +874,61 @@ enum HarnessValidation { } checks["mediaCaptureStopped"] = true + // Like Chrome's "Allow this time", that allow leaves a one-time grant: + // permissions.query reports granted and enumerateDevices exposes IDs and + // labels, which sites such as Zoom and Meet need to pick a device. + let mediaOrigin = configuration.secureOriginString + let mediaDevices = configuration.phased(configuration.mediaPage, "devices") + func mediaDevicesTitle(_ state: String, _ listed: Bool) -> String { + "Cobble Devices \(configuration.token) \(state) \(state) \(listed) \(listed)" + } + try validationPage.load(mediaDevices) + try await wait(for: validationPage, url: mediaDevices, title: mediaDevicesTitle("granted", true)) + checks["mediaAllowExposesDevices"] = true + var exactRequests: [ChromiumMediaPermissionRequest] = [] + runtime.onMediaPermissionRequest = { exactRequests.append($0); $0.allow() } + let exactMedia = configuration.phased(configuration.mediaPage, "exact") + try validationPage.load(exactMedia) + try await wait(for: validationPage, url: exactMedia, + title: "Cobble Exact Granted \(configuration.token)") + checks["mediaExactDeviceGranted"] = exactRequests.count == 1 && + exactRequests[0].kinds == [.camera, .microphone] + guard validationPage.stopMediaCapture() else { + throw ValidationError("Native media capture stop was rejected after the exact-device request.") + } + try await waitForCondition("exact-device media capture stop") { + !validationPage.isCapturingMicrophone && !validationPage.isCapturingCamera + } + runtime.onMediaPermissionRequest = nil + guard validationPage.context.resetPermission([.camera, .microphone], origin: mediaOrigin) else { + throw ValidationError("Native camera and microphone reset was rejected.") + } + try validationPage.load(mediaDevices) + try await wait(for: validationPage, url: mediaDevices, title: mediaDevicesTitle("prompt", false)) + checks["mediaResetHidesDevices"] = true + // Saved host decisions answer the same quiet checks. + var mediaResolved: [(ChromiumMediaPermissionKinds, String, String)] = [] + var mediaSaved = ChromiumPermissionSetting.allow + validationPage.context.permissionResolver = { kind, requesting, embedding in + mediaResolved.append((kind, requesting, embedding)) + return kind == .windowManagement ? .ask : mediaSaved + } + try validationPage.load(mediaDevices) + try await wait(for: validationPage, url: mediaDevices, title: mediaDevicesTitle("granted", true)) + mediaSaved = .deny + try validationPage.load(mediaDevices) + try await wait(for: validationPage, url: mediaDevices, title: mediaDevicesTitle("denied", false)) + validationPage.context.permissionResolver = nil + checks["mediaSavedDecisionsAnswerQuietly"] = mediaResolved.contains { $0.0 == .camera } && + mediaResolved.contains { $0.0 == .microphone } && + mediaResolved.allSatisfy { + ($0.0 == .camera || $0.0 == .microphone) && $0.1 == mediaOrigin && $0.2 == mediaOrigin + } + checks["mediaResetValidatesKind"] = + !validationPage.context.resetPermission([], origin: mediaOrigin) && + !validationPage.context.resetPermission([.camera, .display], origin: mediaOrigin) && + !validationPage.context.resetPermission(.camera, origin: mediaOrigin + "/path") + var navigatedRequest: ChromiumMediaPermissionRequest? var navigationCancelled = false runtime.onMediaPermissionRequest = { request in diff --git a/Sources/CobbleChromium/ChromiumContext.swift b/Sources/CobbleChromium/ChromiumContext.swift index 21b52eb..58decd9 100644 --- a/Sources/CobbleChromium/ChromiumContext.swift +++ b/Sources/CobbleChromium/ChromiumContext.swift @@ -28,10 +28,12 @@ import CCobbleChromium handle, callback == nil ? nil : Unmanaged.passUnretained(self).toOpaque(), callback) } } - /// Answers Chromium's window-management status checks, including quiet checks - /// on load and `permissions.query`, from the host's saved decisions. Called - /// synchronously on Chromium's UI thread with serialized origins; do not - /// navigate or close the context from it. + /// Answers Chromium's camera, microphone and window-management status checks, + /// including quiet checks on load, `enumerateDevices` device details and + /// `permissions.query`, from the host's saved decisions. Camera and microphone + /// pass the top-level origin as both origins. Called synchronously on + /// Chromium's UI thread with serialized origins; do not navigate or close the + /// context from it. public var permissionResolver: ((ChromiumMediaPermissionKinds, String, String) -> ChromiumPermissionSetting)? { didSet { guard !isClosed else { return } @@ -99,9 +101,11 @@ import CCobbleChromium } /// Forgets Chromium's session grant for a serialized origin such as `https://example.com`. - /// Only `.windowManagement` is stored by Chromium. + /// Accepts `.camera`, `.microphone` and `.windowManagement`; allowing camera or + /// microphone leaves a one-time grant for the request's top-level origin. @discardableResult public func resetPermission(_ kinds: ChromiumMediaPermissionKinds, origin: String) -> Bool { - guard !isClosed, kinds == .windowManagement else { return false } + guard !isClosed, !kinds.isEmpty, + kinds.isSubset(of: [.camera, .microphone, .windowManagement]) else { return false } return runtime.api.context_reset_permission?(handle, origin, kinds.rawValue) == 1 } diff --git a/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.h b/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.h index bcb2388..b2442fc 100644 --- a/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.h +++ b/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.h @@ -35,8 +35,10 @@ typedef int32_t (*CCSIdentityResolver)(void* user_data, const char* url_utf8); // ABI 19: synchronous on Chromium's UI thread whenever Chromium checks a // host-decided permission's status, including quiet checks without a prompt. -// `kind` is a CCSMediaPermissionKind; only WINDOW_MANAGEMENT is asked today. -// Return 1 for allowed, 2 for denied, or 0 to keep Chromium's session state. +// `kind` is one CCSMediaPermissionKind: MICROPHONE, CAMERA (also asked for +// enumerateDevices and permissions.query, with the top-level origin as both +// origins) or WINDOW_MANAGEMENT. Return 1 for allowed, 2 for denied, or 0 to +// keep Chromium's session state. // Origin storage is valid only while the callback runs. typedef int32_t (*CCSPermissionResolver)(void* user_data, uint32_t kind, @@ -470,9 +472,10 @@ CCS_EXPORT void CCSContextOpen(const char* profile_key_utf8, CCSContextOpenedCallback callback); CCS_EXPORT void CCSContextRelease(CCSContextRef context); // ABI 19: forgets Chromium's session grant of `kinds` for a serialized origin -// such as "https://example.com". Only CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT is -// accepted; Chromium stores no other host-decided permission. Returns zero for -// an invalid context, origin or kind. +// such as "https://example.com". Accepts MICROPHONE, CAMERA and +// WINDOW_MANAGEMENT; an allowed camera or microphone request leaves a one-time +// grant for its top-level origin. Returns zero for an invalid context, origin +// or kind. CCS_EXPORT uint8_t CCSContextResetPermission(CCSContextRef context, const char* origin_utf8, uint32_t kinds); diff --git a/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.mm b/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.mm index 97655f9..0dc99de 100644 --- a/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.mm +++ b/chromium/overlay/chrome/browser/ui/cobble/cobble_chromium.mm @@ -44,6 +44,7 @@ #include "chrome/browser/lifetime/browser_shutdown.h" #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h" #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h" +#include "chrome/browser/media/webrtc/media_stream_device_permission_context.h" #include "chrome/browser/permissions/system/system_media_capture_permissions_mac.h" #include "chrome/browser/profiles/nuke_profile_directory_utils.h" #include "chrome/browser/profiles/profile.h" @@ -63,6 +64,7 @@ #include "chrome/common/pref_names.h" #include "components/autofill/core/common/autofill_prefs.h" #include "components/content_settings/core/browser/host_content_settings_map.h" +#include "components/content_settings/core/common/content_settings_constraints.h" #include "components/history/core/common/pref_names.h" #include "components/keep_alive_registry/keep_alive_registry.h" #include "components/find_in_page/find_result_observer.h" @@ -548,6 +550,40 @@ void FinishMediaRequest(uint64_t id, FinishMediaRequest(id, result, devices, notify_cancelled); } +// Like Chrome's "Allow this time": after the host allows camera or microphone, +// Chromium keeps a one-time grant so enumerateDevices exposes device IDs and +// labels and permissions.query reports granted, as sites such as Zoom and Meet +// expect. Camera and microphone are delegated, so the grant belongs to the +// top-level origin. It lasts while the site stays open, as in Chrome, and +// CCSContextResetPermission clears it. +void GrantMediaForSession(const CCSMediaPermissionRequest& request) { + content::RenderFrameHost* frame = + content::RenderFrameHost::FromID(request.frame_id); + if (!frame) { + return; + } + const url::Origin top = frame->GetMainFrame()->GetLastCommittedOrigin(); + if (top.opaque() || !network::IsOriginPotentiallyTrustworthy(top)) { + return; + } + const GURL url = top.GetURL(); + content_settings::ContentSettingConstraints constraints; + constraints.set_session_model( + content_settings::mojom::SessionModel::ONE_TIME); + HostContentSettingsMap* map = HostContentSettingsMapFactory::GetForProfile( + Profile::FromBrowserContext(frame->GetBrowserContext())); + if (request.kinds & CCS_MEDIA_PERMISSION_MICROPHONE) { + map->SetContentSettingDefaultScope(url, url, + ContentSettingsType::MEDIASTREAM_MIC, + CONTENT_SETTING_ALLOW, constraints); + } + if (request.kinds & CCS_MEDIA_PERMISSION_CAMERA) { + map->SetContentSettingDefaultScope(url, url, + ContentSettingsType::MEDIASTREAM_CAMERA, + CONTENT_SETTING_ALLOW, constraints); + } +} + void ContinueAllowedMediaRequest(uint64_t id) { CCSMediaPermissionRequest* pending = FindMediaRequest(id); if (!pending || !MediaRequestIsLive(*pending)) { @@ -607,6 +643,7 @@ void ContinueAllowedMediaRequest(uint64_t id) { return; } } + GrantMediaForSession(*pending); blink::mojom::StreamDevicesSet devices; devices.stream_devices.push_back(std::move(stream)); FinishMediaRequest(id, MediaResult::OK, devices); @@ -791,10 +828,12 @@ bool RoutePermissionRequest( return true; } -// Saved host decisions answer Chromium's window-management status checks, so a -// remembered allow or deny also holds for quiet checks and permissions.query. -std::optional ResolveWindowManagementStatus( +// Saved host decisions answer Chromium's status checks for host-decided +// permissions, so a remembered allow or deny also holds for quiet checks, +// enumerateDevices and permissions.query. +std::optional ResolveHostPermissionStatus( content::BrowserContext* browser_context, + uint32_t kind, const GURL& requesting_origin, const GURL& embedding_origin) { CheckUIThread(); @@ -807,10 +846,9 @@ bool RoutePermissionRequest( url::Origin::Create(requesting_origin).Serialize(); const std::string embedding = url::Origin::Create(embedding_origin).Serialize(); - switch (context->permission_resolver( - context->permission_resolver_data, - CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT, requesting.c_str(), - embedding.c_str())) { + switch (context->permission_resolver(context->permission_resolver_data, + kind, requesting.c_str(), + embedding.c_str())) { case 1: return CONTENT_SETTING_ALLOW; case 2: @@ -822,6 +860,32 @@ bool RoutePermissionRequest( return std::nullopt; } +std::optional ResolveWindowManagementStatus( + content::BrowserContext* browser_context, + const GURL& requesting_origin, + const GURL& embedding_origin) { + return ResolveHostPermissionStatus(browser_context, + CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT, + requesting_origin, embedding_origin); +} + +std::optional ResolveMediaStreamStatus( + content::BrowserContext* browser_context, + ContentSettingsType type, + const GURL& requesting_origin, + const GURL& embedding_origin) { + const uint32_t kind = type == ContentSettingsType::MEDIASTREAM_MIC + ? CCS_MEDIA_PERMISSION_MICROPHONE + : type == ContentSettingsType::MEDIASTREAM_CAMERA + ? CCS_MEDIA_PERMISSION_CAMERA + : 0; + if (!kind) { + return std::nullopt; + } + return ResolveHostPermissionStatus(browser_context, kind, requesting_origin, + embedding_origin); +} + BrowserEntry* EntryForBrowser(Browser* browser) { for (BrowserEntry& entry : State().browsers) { if (entry.browser == browser) { @@ -1683,6 +1747,8 @@ void PostMainMessageLoopRun() override { &RoutePermissionRequest); permissions::WindowManagementPermissionContext::SetEmbedderStatusResolver( &ResolveWindowManagementStatus); + MediaStreamDevicePermissionContext::SetEmbedderStatusResolver( + &ResolveMediaStreamStatus); return 0; } @@ -1815,8 +1881,11 @@ void PostMainMessageLoopRun() override { const char* origin_utf8, uint32_t kinds) { CheckUIThread(); - if (!context || !context->profile || !origin_utf8 || - kinds != CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT) { + constexpr uint32_t kResettable = CCS_MEDIA_PERMISSION_MICROPHONE | + CCS_MEDIA_PERMISSION_CAMERA | + CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT; + if (!context || !context->profile || !origin_utf8 || !kinds || + (kinds & ~kResettable)) { return 0; } const GURL url(origin_utf8); @@ -1824,13 +1893,24 @@ void PostMainMessageLoopRun() override { if (!url.is_valid() || origin.opaque() || origin.Serialize() != origin_utf8) { return 0; } - HostContentSettingsMapFactory::GetForProfile(context->profile) - ->ClearSettingsForOneTypeWithPredicate( - ContentSettingsType::WINDOW_MANAGEMENT, - [&url](const ContentSettingPatternSource& setting) { - return setting.primary_pattern != ContentSettingsPattern::Wildcard() && - setting.primary_pattern.Matches(url); - }); + HostContentSettingsMap* map = + HostContentSettingsMapFactory::GetForProfile(context->profile); + const auto clear = [map, &url](ContentSettingsType type) { + map->ClearSettingsForOneTypeWithPredicate( + type, [&url](const ContentSettingPatternSource& setting) { + return setting.primary_pattern != ContentSettingsPattern::Wildcard() && + setting.primary_pattern.Matches(url); + }); + }; + if (kinds & CCS_MEDIA_PERMISSION_MICROPHONE) { + clear(ContentSettingsType::MEDIASTREAM_MIC); + } + if (kinds & CCS_MEDIA_PERMISSION_CAMERA) { + clear(ContentSettingsType::MEDIASTREAM_CAMERA); + } + if (kinds & CCS_MEDIA_PERMISSION_WINDOW_MANAGEMENT) { + clear(ContentSettingsType::WINDOW_MANAGEMENT); + } return 1; } diff --git a/chromium/patches/0040-route-media-permission-status.patch b/chromium/patches/0040-route-media-permission-status.patch new file mode 100644 index 0000000..cc3c1e1 --- /dev/null +++ b/chromium/patches/0040-route-media-permission-status.patch @@ -0,0 +1,67 @@ +diff --git a/chrome/browser/media/webrtc/media_stream_device_permission_context.cc b/chrome/browser/media/webrtc/media_stream_device_permission_context.cc +index 20e9025814..e4988ebb9b 100644 +--- a/chrome/browser/media/webrtc/media_stream_device_permission_context.cc ++++ b/chrome/browser/media/webrtc/media_stream_device_permission_context.cc +@@ -58,8 +58,17 @@ network::mojom::PermissionsPolicyFeature GetPermissionsPolicyFeature( + return network::mojom::PermissionsPolicyFeature::kCamera; + } + ++MediaStreamDevicePermissionContext::EmbedderStatusResolver ++ g_embedder_status_resolver = nullptr; ++ + } // namespace + ++// static ++void MediaStreamDevicePermissionContext::SetEmbedderStatusResolver( ++ EmbedderStatusResolver resolver) { ++ g_embedder_status_resolver = resolver; ++} ++ + MediaStreamDevicePermissionContext::MediaStreamDevicePermissionContext( + content::BrowserContext* browser_context, + const ContentSettingsType content_settings_type) +@@ -115,6 +124,14 @@ MediaStreamDevicePermissionContext::GetContentSettingStatusInternal( + CHECK_EQ(POLICY_NOT_SET, policy, base::NotFatalUntil::M161); + } + ++ if (g_embedder_status_resolver) { ++ if (std::optional setting = g_embedder_status_resolver( ++ browser_context(), content_settings_type_, requesting_origin, ++ embedding_origin)) { ++ return *setting; ++ } ++ } ++ + // Check the content setting. TODO(raymes): currently mic/camera permission + // doesn't consider the embedder. + ContentSetting setting = permissions::ContentSettingPermissionContextBase:: +diff --git a/chrome/browser/media/webrtc/media_stream_device_permission_context.h b/chrome/browser/media/webrtc/media_stream_device_permission_context.h +index b24017c10a..c49facb9c7 100644 +--- a/chrome/browser/media/webrtc/media_stream_device_permission_context.h ++++ b/chrome/browser/media/webrtc/media_stream_device_permission_context.h +@@ -5,6 +5,8 @@ + #ifndef CHROME_BROWSER_MEDIA_WEBRTC_MEDIA_STREAM_DEVICE_PERMISSION_CONTEXT_H_ + #define CHROME_BROWSER_MEDIA_WEBRTC_MEDIA_STREAM_DEVICE_PERMISSION_CONTEXT_H_ + ++#include ++ + #include "base/memory/weak_ptr.h" + #include "components/content_settings/core/common/content_settings.h" + #include "components/content_settings/core/common/content_settings_types.h" +@@ -37,6 +39,16 @@ class MediaStreamDevicePermissionContext + + ~MediaStreamDevicePermissionContext() override; + ++ // Cobble: lets the embedder answer camera and microphone status from its own ++ // saved site decisions, including quiet checks, enumerateDevices and ++ // permissions.query. nullopt keeps Chromium's stored state. ++ using EmbedderStatusResolver = std::optional (*)( ++ content::BrowserContext* browser_context, ++ ContentSettingsType content_settings_type, ++ const GURL& requesting_origin, ++ const GURL& embedding_origin); ++ static void SetEmbedderStatusResolver(EmbedderStatusResolver resolver); ++ + // PermissionContextBase: + void DecidePermission( + std::unique_ptr request_data, diff --git a/scripts/smoke.mjs b/scripts/smoke.mjs index 56e6662..2d01be5 100755 --- a/scripts/smoke.mjs +++ b/scripts/smoke.mjs @@ -229,9 +229,29 @@ export async function startFixture(token, downloadDirectory) { }); const phase = url.searchParams.get("phase") ?? ""; const display = phase.startsWith("display"); + // What sites such as Zoom read before and after asking: permission + // state, then device IDs and labels, then a stream for a chosen ID. + const devices = `const states = () => Promise.all(["camera", "microphone"].map(name => + navigator.permissions.query({name}).then(status => status.state))); + const listed = () => navigator.mediaDevices.enumerateDevices().then(list => + ["videoinput", "audioinput"].map(kind => + list.find(device => device.kind === kind && device.deviceId && device.label)));`; // Stock Chromium asks only with a click; screens-again checks the // session grant quietly on load. - response.end(phase.startsWith("screens") ? ` + response.end(phase === "devices" ? ` + Cobble Devices Pending ${token}` : phase === "exact" ? ` + Cobble Exact Pending ${token}` : phase.startsWith("screens") ? ` Cobble Screens Pending ${token}