feat: emulate geolocation positionUnavailable (#3359)

Spec is landed in w3c/webdriver-bidi#911

Author: sadym-chromium

src/bidiMapper/modules/browser/UserContextConfig.ts

@@ -28,7 +28,10 @@ export class UserContextConfig {
   readonly userContextId: string;
   viewport?: BrowsingContext.Viewport | null;
   devicePixelRatio?: number | null;
-  emulatedGeolocation?: Emulation.GeolocationCoordinates | null;
+  geolocation?:
+    | Emulation.GeolocationCoordinates
+    | Emulation.GeolocationPositionError
+    | null;
 
   constructor(userContextId: string) {
     this.userContextId = userContextId;

src/bidiMapper/modules/cdp/CdpTarget.ts

@@ -24,6 +24,7 @@ import {
   type ChromiumBidi,
   type Emulation,
   Session,
+  UnknownErrorException,
   UnsupportedOperationException,
 } from '../../../protocol/protocol.js';
 import {Deferred} from '../../../utils/Deferred.js';
@@ -636,13 +637,11 @@ export class CdpTarget {
     }
 
     if (
-      this.#userContextConfig.emulatedGeolocation !== undefined &&
-      this.#userContextConfig.emulatedGeolocation !== null
+      this.#userContextConfig.geolocation !== undefined &&
+      this.#userContextConfig.geolocation !== null
     ) {
       promises.push(
-        this.setGeolocationOverride(
-          this.#userContextConfig.emulatedGeolocation,
-        ),
+        this.setGeolocationOverride(this.#userContextConfig.geolocation),
       );
     }
 
@@ -672,21 +671,38 @@ export class CdpTarget {
   }
 
   async setGeolocationOverride(
-    coordinates: Emulation.GeolocationCoordinates | null,
+    geolocation:
+      | Emulation.GeolocationCoordinates
+      | Emulation.GeolocationPositionError
+      | null,
   ): Promise<void> {
-    if (coordinates === null) {
+    if (geolocation === null) {
       await this.cdpClient.sendCommand('Emulation.clearGeolocationOverride');
-    } else {
+    } else if ('type' in geolocation) {
+      if (geolocation.type !== 'positionUnavailable') {
+        // Unreachable. Handled by params parser.
+        throw new UnknownErrorException(
+          `Unknown geolocation error ${geolocation.type}`,
+        );
+      }
+      // Omitting latitude, longitude or accuracy emulates position unavailable.
+      await this.cdpClient.sendCommand('Emulation.setGeolocationOverride', {});
+    } else if ('latitude' in geolocation) {
       await this.cdpClient.sendCommand('Emulation.setGeolocationOverride', {
-        latitude: coordinates.latitude,
-        longitude: coordinates.longitude,
-        accuracy: coordinates.accuracy ?? 1,
+        latitude: geolocation.latitude,
+        longitude: geolocation.longitude,
+        accuracy: geolocation.accuracy ?? 1,
         // `null` value is treated as "missing".
-        altitude: coordinates.altitude ?? undefined,
-        altitudeAccuracy: coordinates.altitudeAccuracy ?? undefined,
-        heading: coordinates.heading ?? undefined,
-        speed: coordinates.speed ?? undefined,
+        altitude: geolocation.altitude ?? undefined,
+        altitudeAccuracy: geolocation.altitudeAccuracy ?? undefined,
+        heading: geolocation.heading ?? undefined,
+        speed: geolocation.speed ?? undefined,
       });
+    } else {
+      // Unreachable. Handled by params parser.
+      throw new UnknownErrorException(
+        'Unexpected geolocation coordinates value',
+      );
     }
   }
 }

src/bidiMapper/modules/emulation/EmulationProcessor.ts

@@ -39,15 +39,42 @@ export class EmulationProcessor {
   async setGeolocationOverride(
     params: Emulation.SetGeolocationOverrideParameters,
   ): Promise<EmptyResult> {
-    if (
-      (params.coordinates?.altitude ?? null) === null &&
-      (params.coordinates?.altitudeAccuracy ?? null) !== null
-    ) {
+    if ('coordinates' in params && 'error' in params) {
+      // Unreachable. Handled by params parser.
       throw new InvalidArgumentException(
-        'Geolocation altitudeAccuracy can be set only with altitude',
+        'Coordinates and error cannot be set at the same time',
       );
     }
 
+    let geolocation:
+      | Emulation.GeolocationCoordinates
+      | Emulation.GeolocationPositionError
+      | null = null;
+
+    if ('coordinates' in params) {
+      if (
+        (params.coordinates?.altitude ?? null) === null &&
+        (params.coordinates?.altitudeAccuracy ?? null) !== null
+      ) {
+        throw new InvalidArgumentException(
+          'Geolocation altitudeAccuracy can be set only with altitude',
+        );
+      }
+
+      geolocation = params.coordinates;
+    } else if ('error' in params) {
+      if (params.error.type !== 'positionUnavailable') {
+        // Unreachable. Handled by params parser.
+        throw new InvalidArgumentException(
+          `Unknown geolocation error ${params.error.type}`,
+        );
+      }
+      geolocation = params.error;
+    } else {
+      // Unreachable. Handled by params parser.
+      throw new InvalidArgumentException(`Coordinates or error should be set`);
+    }
+
     const browsingContexts = await this.#getRelatedTopLevelBrowsingContexts(
       params.contexts,
       params.userContexts,
@@ -56,13 +83,13 @@ export class EmulationProcessor {
     for (const userContextId of params.userContexts ?? []) {
       const userContextConfig =
         this.#userContextStorage.getConfig(userContextId);
-      userContextConfig.emulatedGeolocation = params.coordinates;
+      userContextConfig.geolocation = geolocation;
     }
 
     await Promise.all(
       browsingContexts.map(
         async (context) =>
-          await context.cdpTarget.setGeolocationOverride(params.coordinates),
+          await context.cdpTarget.setGeolocationOverride(geolocation),
       ),
     );
     return {};

src/protocol-parser/generated/webdriver-bidi.ts

@@ -1176,14 +1176,27 @@ export namespace Emulation {
 }
 export namespace Emulation {
   export const SetGeolocationOverrideParametersSchema = z.lazy(() =>
-    z.object({
-      coordinates: z.union([Emulation.GeolocationCoordinatesSchema, z.null()]),
-      contexts: z
-        .array(BrowsingContext.BrowsingContextSchema)
-        .min(1)
-        .optional(),
-      userContexts: z.array(Browser.UserContextSchema).min(1).optional(),
-    }),
+    z
+      .union([
+        z.object({
+          coordinates: z.union([
+            Emulation.GeolocationCoordinatesSchema,
+            z.null(),
+          ]),
+        }),
+        z.object({
+          error: Emulation.GeolocationPositionErrorSchema,
+        }),
+      ])
+      .and(
+        z.object({
+          contexts: z
+            .array(BrowsingContext.BrowsingContextSchema)
+            .min(1)
+            .optional(),
+          userContexts: z.array(Browser.UserContextSchema).min(1).optional(),
+        }),
+      ),
   );
 }
 export namespace Emulation {
@@ -1203,6 +1216,13 @@ export namespace Emulation {
     }),
   );
 }
+export namespace Emulation {
+  export const GeolocationPositionErrorSchema = z.lazy(() =>
+    z.object({
+      type: z.literal('positionUnavailable'),
+    }),
+  );
+}
 export const NetworkCommandSchema = z.lazy(() =>
   z.union([
     Network.AddInterceptSchema,

src/protocol-parser/protocol-parser.ts

@@ -297,6 +297,14 @@ export namespace Session {
 
 export namespace Emulation {
   export function parseSetGeolocationOverrideParams(params: unknown) {
+    if ('coordinates' in (params as object) && 'error' in (params as object)) {
+      // Zod picks the first matching parameter omitting the other. In this case, the
+      // `parseObject` will remove `error` from the params. However, specification
+      // requires to throw an exception.
+      throw new InvalidArgumentException(
+        'Coordinates and error cannot be set at the same time',
+      );
+    }
     return parseObject(
       params,
       WebDriverBidi.Emulation.SetGeolocationOverrideParametersSchema,

src/protocol/generated/webdriver-bidi.ts

@@ -949,8 +949,14 @@ export namespace Emulation {
   };
 }
 export namespace Emulation {
-  export type SetGeolocationOverrideParameters = {
-    coordinates: Emulation.GeolocationCoordinates | null;
+  export type SetGeolocationOverrideParameters = (
+    | {
+        coordinates: Emulation.GeolocationCoordinates | null;
+      }
+    | {
+        error: Emulation.GeolocationPositionError;
+      }
+  ) & {
     contexts?: [
       BrowsingContext.BrowsingContext,
       ...BrowsingContext.BrowsingContext[],
@@ -998,6 +1004,11 @@ export namespace Emulation {
     speed?: number | null;
   };
 }
+export namespace Emulation {
+  export type GeolocationPositionError = {
+    type: 'positionUnavailable';
+  };
+}
 export type NetworkCommand =
   | Network.AddIntercept
   | Network.ContinueRequest

tests/emulation/__snapshots__/test_geolocation.ambr

@@ -1,4 +1,18 @@
 # serializer version: 1
+# name: test_geolocation_emulate_unavailable
+  dict({
+    'type': 'object',
+    'value': list([
+      list([
+        'code',
+        dict({
+          'type': 'number',
+          'value': 2,
+        }),
+      ]),
+    ]),
+  })
+# ---
 # name: test_geolocation_per_user_context
   dict({
     'type': 'object',

tests/emulation/test_geolocation.py

@@ -58,7 +58,7 @@ async def get_geolocation(websocket, context_id):
                         new Promise(
                             resolve => window.navigator.geolocation.getCurrentPosition(
                                 position => resolve(position.coords.toJSON()),
-                                error => resolve({code: error.code, message: error.message}),
+                                error => resolve({code: error.code}),
                                 {timeout: 200}
                         ))
                     """,
@@ -123,6 +123,47 @@ async def test_geolocation_set_and_clear(websocket, context_id, url_example,
     assert initial_geolocation == await get_geolocation(websocket, context_id)
 
 
+@pytest.mark.asyncio
+async def test_geolocation_emulate_unavailable(websocket, context_id,
+                                               url_example, snapshot):
+    await goto_url(websocket, context_id, url_example)
+
+    await set_permission(websocket, get_origin(url_example),
+                         {'name': 'geolocation'}, 'granted')
+
+    initial_geolocation = await get_geolocation(websocket, context_id)
+
+    await execute_command(
+        websocket, {
+            'method': 'emulation.setGeolocationOverride',
+            'params': {
+                'contexts': [context_id],
+                'error': {
+                    'type': 'positionUnavailable'
+                }
+            }
+        })
+
+    emulated_geolocation = await get_geolocation(websocket, context_id)
+
+    assert initial_geolocation != emulated_geolocation, "Geolocation should have changed"
+    assert emulated_geolocation == snapshot(
+    ), "New geolocation should match snapshot"
+
+    # Clear geolocation override.
+    await execute_command(
+        websocket, {
+            'method': 'emulation.setGeolocationOverride',
+            'params': {
+                'contexts': [context_id],
+                'coordinates': None
+            }
+        })
+
+    # Assert the geolocation has returned to the original state.
+    assert initial_geolocation == await get_geolocation(websocket, context_id)
+
+
 @pytest.mark.asyncio
 async def test_geolocation_per_user_context(websocket, url_example,
                                             url_example_another_origin,