Bug 1575144 - Update Geolocation implementation to match latest spec r=baku,marcosc
authorSid Vishnoi <sidvishnoi8@gmail.com>
Wed, 06 Nov 2019 12:35:42 +0000
changeset 500833 aab5f870bf5e1f623eba7cd53b65d22c1c852d4b
parent 500832 8189d25586fb6dd2d8e4f5bafbc43a1e31f4988e
child 500834 90da3a622fbfa8d4b6fd0a9c01c1915d5aacefd8
push id114166
push userapavel@mozilla.com
push dateThu, 07 Nov 2019 10:04:01 +0000
treeherdermozilla-inbound@d271c572a9bc [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbaku, marcosc
bugs1575144
milestone72.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1575144 - Update Geolocation implementation to match latest spec r=baku,marcosc The Geolocation API specification renamed the following interfaces and removed the [NoInterfaceObject] annotation so that these types are now exposed to script: * Coordinates -> GeolocationCoordinates * Position -> GeolocationPosition * PositionError -> GeolocationPositionError This is done in response to an effort to remove the [NoInterfaceObject] annotation from WebIDL. Additionally, the following interfaces are now only exposed in Secure Contexts: * GeolocationCoordinates * GeolocationPosition Differential Revision: https://phabricator.services.mozilla.com/D51972
dom/bindings/Bindings.conf
dom/geolocation/GeolocationPositionError.cpp
dom/geolocation/GeolocationPositionError.h
dom/geolocation/PositionError.cpp
dom/geolocation/PositionError.h
dom/geolocation/moz.build
dom/geolocation/nsGeoPosition.cpp
dom/geolocation/nsGeoPosition.h
dom/geolocation/nsGeolocation.cpp
dom/interfaces/geolocation/nsIDOMGeoPositionErrorCallback.idl
dom/ipc/ContentParent.cpp
dom/system/linux/GpsdLocationProvider.cpp
dom/system/mac/CoreLocationLocationProvider.mm
dom/system/windows/WindowsLocationProvider.cpp
dom/tests/mochitest/general/test_interfaces.js
dom/webidl/Coordinates.webidl
dom/webidl/Geolocation.webidl
dom/webidl/GeolocationCoordinates.webidl
dom/webidl/GeolocationPosition.webidl
dom/webidl/GeolocationPositionError.webidl
dom/webidl/Position.webidl
dom/webidl/PositionError.webidl
dom/webidl/moz.build
testing/web-platform/meta/geolocation-API/getCurrentPosition_IDL.https.html.ini
testing/web-platform/meta/geolocation-API/idlharness.https.window.js.ini
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -130,17 +130,17 @@ DOMInterfaces = {
 'ConsoleInstance': {
     'implicitJSContext': ['clear', 'count', 'countReset', 'groupEnd', 'time', 'timeEnd'],
 },
 
 'ConvolverNode': {
     'implicitJSContext': [ 'buffer' ],
 },
 
-'Coordinates': {
+'GeolocationCoordinates': {
     'headerFile': 'nsGeoPosition.h'
 },
 
 'Credential' : {
     'concrete': True,
 },
 
 'Crypto' : {
@@ -632,17 +632,17 @@ DOMInterfaces = {
 'PluginTag': {
     'nativeType': 'nsIPluginTag',
 },
 
 'Policy': {
     'nativeType': 'mozilla::dom::FeaturePolicy',
 },
 
-'Position': {
+'GeolocationPosition': {
     'headerFile': 'nsGeoPosition.h'
 },
 
 'PromiseNativeHandler': {
     'wrapperCache': False,
 },
 
 'PushEvent': {
rename from dom/geolocation/PositionError.cpp
rename to dom/geolocation/GeolocationPositionError.cpp
--- a/dom/geolocation/PositionError.cpp
+++ b/dom/geolocation/GeolocationPositionError.cpp
@@ -1,55 +1,59 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "mozilla/dom/PositionError.h"
-#include "mozilla/dom/PositionErrorBinding.h"
+#include "mozilla/dom/GeolocationPositionError.h"
+#include "mozilla/dom/GeolocationPositionErrorBinding.h"
 #include "mozilla/CycleCollectedJSContext.h"  // for nsAutoMicroTask
 #include "nsGeolocation.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PositionError, mParent)
-NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(PositionError, AddRef)
-NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(PositionError, Release)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(GeolocationPositionError, mParent)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(GeolocationPositionError, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(GeolocationPositionError, Release)
 
-PositionError::PositionError(Geolocation* aParent, int16_t aCode)
+GeolocationPositionError::GeolocationPositionError(Geolocation* aParent,
+                                                   int16_t aCode)
     : mCode(aCode), mParent(aParent) {}
 
-PositionError::~PositionError() = default;
+GeolocationPositionError::~GeolocationPositionError() = default;
 
-void PositionError::GetMessage(nsAString& aMessage) const {
+void GeolocationPositionError::GetMessage(nsAString& aMessage) const {
   switch (mCode) {
-    case PositionError_Binding::PERMISSION_DENIED:
+    case GeolocationPositionError_Binding::PERMISSION_DENIED:
       aMessage = NS_LITERAL_STRING("User denied geolocation prompt");
       break;
-    case PositionError_Binding::POSITION_UNAVAILABLE:
+    case GeolocationPositionError_Binding::POSITION_UNAVAILABLE:
       aMessage = NS_LITERAL_STRING("Unknown error acquiring position");
       break;
-    case PositionError_Binding::TIMEOUT:
+    case GeolocationPositionError_Binding::TIMEOUT:
       aMessage = NS_LITERAL_STRING("Position acquisition timed out");
       break;
     default:
       break;
   }
 }
 
-nsWrapperCache* PositionError::GetParentObject() const { return mParent; }
-
-JSObject* PositionError::WrapObject(JSContext* aCx,
-                                    JS::Handle<JSObject*> aGivenProto) {
-  return PositionError_Binding::Wrap(aCx, this, aGivenProto);
+nsWrapperCache* GeolocationPositionError::GetParentObject() const {
+  return mParent;
 }
 
-void PositionError::NotifyCallback(const GeoPositionErrorCallback& aCallback) {
+JSObject* GeolocationPositionError::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return GeolocationPositionError_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void GeolocationPositionError::NotifyCallback(
+    const GeoPositionErrorCallback& aCallback) {
   nsAutoMicroTask mt;
   if (aCallback.HasWebIDLCallback()) {
     RefPtr<PositionErrorCallback> callback = aCallback.GetWebIDLCallback();
 
     if (callback) {
       callback->Call(*this);
     }
   } else {
rename from dom/geolocation/PositionError.h
rename to dom/geolocation/GeolocationPositionError.h
--- a/dom/geolocation/PositionError.h
+++ b/dom/geolocation/GeolocationPositionError.h
@@ -17,37 +17,37 @@ class nsIDOMGeoPositionErrorCallback;
 namespace mozilla {
 namespace dom {
 class PositionErrorCallback;
 class Geolocation;
 typedef CallbackObjectHolder<PositionErrorCallback,
                              nsIDOMGeoPositionErrorCallback>
     GeoPositionErrorCallback;
 
-class PositionError final : public nsWrapperCache {
+class GeolocationPositionError final : public nsWrapperCache {
  public:
-  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PositionError)
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(PositionError)
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(GeolocationPositionError)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(GeolocationPositionError)
 
-  PositionError(Geolocation* aParent, int16_t aCode);
+  GeolocationPositionError(Geolocation* aParent, int16_t aCode);
 
   nsWrapperCache* GetParentObject() const;
 
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
   int16_t Code() const { return mCode; }
 
   void GetMessage(nsAString& aMessage) const;
 
   MOZ_CAN_RUN_SCRIPT
   void NotifyCallback(const GeoPositionErrorCallback& callback);
 
  private:
-  ~PositionError();
+  ~GeolocationPositionError();
   int16_t mCode;
   RefPtr<Geolocation> mParent;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif /* mozilla_dom_PositionError_h */
--- a/dom/geolocation/moz.build
+++ b/dom/geolocation/moz.build
@@ -8,22 +8,22 @@ with Files("**"):
     BUG_COMPONENT = ("Core", "DOM: Geolocation")
 
 EXPORTS += [
     'nsGeoPosition.h',
     'nsGeoPositionIPCSerialiser.h',
 ]
 
 EXPORTS.mozilla.dom += [
-    'PositionError.h',
+    'GeolocationPositionError.h',
 ]
 
 SOURCES += [
+    'GeolocationPositionError.cpp',
     'nsGeolocation.cpp',
-    'PositionError.cpp',
 ]
 
 UNIFIED_SOURCES += [
     'MLSFallback.cpp',
     'nsGeoPosition.cpp',
 ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
--- a/dom/geolocation/nsGeoPosition.cpp
+++ b/dom/geolocation/nsGeoPosition.cpp
@@ -2,18 +2,18 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsGeoPosition.h"
 
 #include "mozilla/FloatingPoint.h"
-#include "mozilla/dom/PositionBinding.h"
-#include "mozilla/dom/CoordinatesBinding.h"
+#include "mozilla/dom/GeolocationPositionBinding.h"
+#include "mozilla/dom/GeolocationCoordinatesBinding.h"
 
 using mozilla::EqualOrBothNaN;
 using mozilla::IsNaN;
 
 // NaN() is a more convenient function name.
 inline double NaN() { return mozilla::UnspecifiedNaN<double>(); }
 
 ////////////////////////////////////////////////////
@@ -139,91 +139,96 @@ NS_IMETHODIMP
 nsGeoPosition::GetCoords(nsIDOMGeoPositionCoords** aCoords) {
   NS_IF_ADDREF(*aCoords = mCoords);
   return NS_OK;
 }
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Position, mParent, mCoordinates)
-NS_IMPL_CYCLE_COLLECTING_ADDREF(Position)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(Position)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Position)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(GeolocationPosition, mParent,
+                                      mCoordinates)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(GeolocationPosition)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(GeolocationPosition)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(GeolocationPosition)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
-Position::Position(nsISupports* aParent, nsIDOMGeoPosition* aGeoPosition)
+GeolocationPosition::GeolocationPosition(nsISupports* aParent,
+                                         nsIDOMGeoPosition* aGeoPosition)
     : mParent(aParent), mGeoPosition(aGeoPosition) {}
 
-Position::~Position() {}
+GeolocationPosition::~GeolocationPosition() {}
 
-nsISupports* Position::GetParentObject() const { return mParent; }
+nsISupports* GeolocationPosition::GetParentObject() const { return mParent; }
 
-JSObject* Position::WrapObject(JSContext* aCx,
-                               JS::Handle<JSObject*> aGivenProto) {
-  return Position_Binding::Wrap(aCx, this, aGivenProto);
+JSObject* GeolocationPosition::WrapObject(JSContext* aCx,
+                                          JS::Handle<JSObject*> aGivenProto) {
+  return GeolocationPosition_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-Coordinates* Position::Coords() {
+GeolocationCoordinates* GeolocationPosition::Coords() {
   if (!mCoordinates) {
     nsCOMPtr<nsIDOMGeoPositionCoords> coords;
     mGeoPosition->GetCoords(getter_AddRefs(coords));
     MOZ_ASSERT(coords, "coords should not be null");
 
-    mCoordinates = new Coordinates(this, coords);
+    mCoordinates = new GeolocationCoordinates(this, coords);
   }
 
   return mCoordinates;
 }
 
-uint64_t Position::Timestamp() const {
+uint64_t GeolocationPosition::Timestamp() const {
   uint64_t rv;
 
   mGeoPosition->GetTimestamp(&rv);
   return rv;
 }
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Coordinates, mPosition)
-NS_IMPL_CYCLE_COLLECTING_ADDREF(Coordinates)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(Coordinates)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Coordinates)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(GeolocationCoordinates, mPosition)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(GeolocationCoordinates)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(GeolocationCoordinates)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(GeolocationCoordinates)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
-Coordinates::Coordinates(Position* aPosition, nsIDOMGeoPositionCoords* aCoords)
+GeolocationCoordinates::GeolocationCoordinates(GeolocationPosition* aPosition,
+                                               nsIDOMGeoPositionCoords* aCoords)
     : mPosition(aPosition), mCoords(aCoords) {}
 
-Coordinates::~Coordinates() {}
-
-Position* Coordinates::GetParentObject() const { return mPosition; }
+GeolocationCoordinates::~GeolocationCoordinates() {}
 
-JSObject* Coordinates::WrapObject(JSContext* aCx,
-                                  JS::Handle<JSObject*> aGivenProto) {
-  return Coordinates_Binding::Wrap(aCx, this, aGivenProto);
+GeolocationPosition* GeolocationCoordinates::GetParentObject() const {
+  return mPosition;
+}
+
+JSObject* GeolocationCoordinates::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return GeolocationCoordinates_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-#define GENERATE_COORDS_WRAPPED_GETTER(name) \
-  double Coordinates::name() const {         \
-    double rv;                               \
-    mCoords->Get##name(&rv);                 \
-    return rv;                               \
+#define GENERATE_COORDS_WRAPPED_GETTER(name)    \
+  double GeolocationCoordinates::name() const { \
+    double rv;                                  \
+    mCoords->Get##name(&rv);                    \
+    return rv;                                  \
   }
 
-#define GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(name) \
-  Nullable<double> Coordinates::Get##name() const {   \
-    double value;                                     \
-    mCoords->Get##name(&value);                       \
-    Nullable<double> rv;                              \
-    if (!IsNaN(value)) {                              \
-      rv.SetValue(value);                             \
-    }                                                 \
-    return rv;                                        \
+#define GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(name)          \
+  Nullable<double> GeolocationCoordinates::Get##name() const { \
+    double value;                                              \
+    mCoords->Get##name(&value);                                \
+    Nullable<double> rv;                                       \
+    if (!IsNaN(value)) {                                       \
+      rv.SetValue(value);                                      \
+    }                                                          \
+    return rv;                                                 \
   }
 
 GENERATE_COORDS_WRAPPED_GETTER(Latitude)
 GENERATE_COORDS_WRAPPED_GETTER(Longitude)
 GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(Altitude)
 GENERATE_COORDS_WRAPPED_GETTER(Accuracy)
 GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(AltitudeAccuracy)
 GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(Heading)
--- a/dom/geolocation/nsGeoPosition.h
+++ b/dom/geolocation/nsGeoPosition.h
@@ -59,56 +59,57 @@ class nsGeoPosition final : public nsIDO
 
 ////////////////////////////////////////////////////
 // WebIDL wrappers for the classes above
 ////////////////////////////////////////////////////
 
 namespace mozilla {
 namespace dom {
 
-class Coordinates;
+class GeolocationCoordinates;
 
-class Position final : public nsISupports, public nsWrapperCache {
-  ~Position();
+class GeolocationPosition final : public nsISupports, public nsWrapperCache {
+  ~GeolocationPosition();
 
  public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Position)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(GeolocationPosition)
 
  public:
-  Position(nsISupports* aParent, nsIDOMGeoPosition* aGeoPosition);
+  GeolocationPosition(nsISupports* aParent, nsIDOMGeoPosition* aGeoPosition);
 
   nsISupports* GetParentObject() const;
 
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
-  Coordinates* Coords();
+  GeolocationCoordinates* Coords();
 
   uint64_t Timestamp() const;
 
   nsIDOMGeoPosition* GetWrappedGeoPosition() { return mGeoPosition; }
 
  private:
-  RefPtr<Coordinates> mCoordinates;
+  RefPtr<GeolocationCoordinates> mCoordinates;
   nsCOMPtr<nsISupports> mParent;
   nsCOMPtr<nsIDOMGeoPosition> mGeoPosition;
 };
 
-class Coordinates final : public nsISupports, public nsWrapperCache {
-  ~Coordinates();
+class GeolocationCoordinates final : public nsISupports, public nsWrapperCache {
+  ~GeolocationCoordinates();
 
  public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Coordinates)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(GeolocationCoordinates)
 
  public:
-  Coordinates(Position* aPosition, nsIDOMGeoPositionCoords* aCoords);
+  GeolocationCoordinates(GeolocationPosition* aPosition,
+                         nsIDOMGeoPositionCoords* aCoords);
 
-  Position* GetParentObject() const;
+  GeolocationPosition* GetParentObject() const;
 
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
   double Latitude() const;
 
   double Longitude() const;
 
@@ -118,16 +119,16 @@ class Coordinates final : public nsISupp
 
   Nullable<double> GetAltitudeAccuracy() const;
 
   Nullable<double> GetHeading() const;
 
   Nullable<double> GetSpeed() const;
 
  private:
-  RefPtr<Position> mPosition;
+  RefPtr<GeolocationPosition> mPosition;
   nsCOMPtr<nsIDOMGeoPositionCoords> mCoords;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif /* nsGeoPosition_h */
--- a/dom/geolocation/nsGeolocation.cpp
+++ b/dom/geolocation/nsGeolocation.cpp
@@ -6,18 +6,18 @@
 
 #include "nsGeolocation.h"
 
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/CycleCollectedJSContext.h"  // for nsAutoMicroTask
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/FeaturePolicyUtils.h"
 #include "mozilla/dom/PermissionMessageUtils.h"
-#include "mozilla/dom/PositionError.h"
-#include "mozilla/dom/PositionErrorBinding.h"
+#include "mozilla/dom/GeolocationPositionError.h"
+#include "mozilla/dom/GeolocationPositionErrorBinding.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "mozilla/StaticPrefs_geo.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/Unused.h"
 #include "mozilla/WeakPtr.h"
 #include "mozilla/EventStateManager.h"
@@ -226,17 +226,17 @@ NS_IMPL_QUERY_INTERFACE_CYCLE_COLLECTION
 NS_IMPL_ADDREF_INHERITED(nsGeolocationRequest, ContentPermissionRequestBase)
 NS_IMPL_RELEASE_INHERITED(nsGeolocationRequest, ContentPermissionRequestBase)
 NS_IMPL_CYCLE_COLLECTION_INHERITED(nsGeolocationRequest,
                                    ContentPermissionRequestBase, mCallback,
                                    mErrorCallback, mLocator)
 
 void nsGeolocationRequest::Notify() {
   SetTimeoutTimer();
-  NotifyErrorAndShutdown(PositionError_Binding::TIMEOUT);
+  NotifyErrorAndShutdown(GeolocationPositionError_Binding::TIMEOUT);
 }
 
 void nsGeolocationRequest::NotifyErrorAndShutdown(uint16_t aErrorCode) {
   MOZ_ASSERT(!mShutdown, "timeout after shutdown");
   if (!mIsWatchPositionRequest) {
     Shutdown();
     mLocator->RemoveRequest(this);
   }
@@ -253,17 +253,17 @@ nsGeolocationRequest::Cancel() {
     Telemetry::Accumulate(Telemetry::GEOLOCATION_REQUEST_GRANTED,
                           mProtocolType);
   }
 
   if (mLocator->ClearPendingRequest(this)) {
     return NS_OK;
   }
 
-  NotifyError(PositionError_Binding::PERMISSION_DENIED);
+  NotifyError(GeolocationPositionError_Binding::PERMISSION_DENIED);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGeolocationRequest::Allow(JS::HandleValue aChoices) {
   MOZ_ASSERT(aChoices.isUndefined());
 
   if (mRequester) {
@@ -328,28 +328,28 @@ nsGeolocationRequest::Allow(JS::HandleVa
     if (!mIsWatchPositionRequest) {
       return NS_OK;
     }
 
   } else {
     // if it is not a watch request and timeout is 0,
     // invoke the errorCallback (if present) with TIMEOUT code
     if (mOptions && mOptions->mTimeout == 0 && !mIsWatchPositionRequest) {
-      NotifyError(PositionError_Binding::TIMEOUT);
+      NotifyError(GeolocationPositionError_Binding::TIMEOUT);
       return NS_OK;
     }
   }
 
   // Kick off the geo device, if it isn't already running
   nsCOMPtr<nsIPrincipal> principal = GetPrincipal();
   nsresult rv = gs->StartDevice(principal);
 
   if (NS_FAILED(rv)) {
     // Location provider error
-    NotifyError(PositionError_Binding::POSITION_UNAVAILABLE);
+    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
     return NS_OK;
   }
 
   if (mIsWatchPositionRequest || !canUseCache) {
     // let the locator know we're pending
     // we will now be owned by the locator
     mLocator->NotifyAllowedRequest(this);
   }
@@ -390,28 +390,29 @@ void nsGeolocationRequest::SendLocation(
     const uint32_t maximumAge_ms = mOptions->mMaximumAge;
     const bool isTooOld = DOMTimeStamp(PR_Now() / PR_USEC_PER_MSEC -
                                        maximumAge_ms) > positionTime_ms;
     if (isTooOld) {
       return;
     }
   }
 
-  RefPtr<mozilla::dom::Position> wrapped;
+  RefPtr<mozilla::dom::GeolocationPosition> wrapped;
 
   if (aPosition) {
     nsCOMPtr<nsIDOMGeoPositionCoords> coords;
     aPosition->GetCoords(getter_AddRefs(coords));
     if (coords) {
-      wrapped = new mozilla::dom::Position(ToSupports(mLocator), aPosition);
+      wrapped = new mozilla::dom::GeolocationPosition(ToSupports(mLocator),
+                                                      aPosition);
     }
   }
 
   if (!wrapped) {
-    NotifyError(PositionError_Binding::POSITION_UNAVAILABLE);
+    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
     return;
   }
 
   if (!mIsWatchPositionRequest) {
     // Cancel timer and position updates in case the position
     // callback spins the event loop
     Shutdown();
   }
@@ -447,17 +448,18 @@ nsGeolocationRequest::Update(nsIDOMGeoPo
   nsCOMPtr<nsIRunnable> ev = new RequestSendLocationEvent(aPosition, this);
   mMainThreadTarget->Dispatch(ev.forget());
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGeolocationRequest::NotifyError(uint16_t aErrorCode) {
   MOZ_ASSERT(NS_IsMainThread());
-  RefPtr<PositionError> positionError = new PositionError(mLocator, aErrorCode);
+  RefPtr<GeolocationPositionError> positionError =
+      new GeolocationPositionError(mLocator, aErrorCode);
   positionError->NotifyCallback(mErrorCallback);
   return NS_OK;
 }
 
 void nsGeolocationRequest::Shutdown() {
   MOZ_ASSERT(!mShutdown, "request shutdown twice");
   mShutdown = true;
 
@@ -662,17 +664,17 @@ nsresult nsGeolocationService::StartDevi
   if (!mProvider) {
     return NS_ERROR_FAILURE;
   }
 
   nsresult rv;
 
   if (NS_FAILED(rv = mProvider->Startup()) ||
       NS_FAILED(rv = mProvider->Watch(this))) {
-    NotifyError(PositionError_Binding::POSITION_UNAVAILABLE);
+    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
     return rv;
   }
 
   obs->NotifyObservers(mProvider, "geolocation-device-events", u"starting");
 
   return NS_OK;
 }
 
--- a/dom/interfaces/geolocation/nsIDOMGeoPositionErrorCallback.idl
+++ b/dom/interfaces/geolocation/nsIDOMGeoPositionErrorCallback.idl
@@ -1,13 +1,13 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 
 #include "domstubs.idl"
 
-webidl PositionError;
+webidl GeolocationPositionError;
 
 [scriptable, function, uuid(7D9B09D9-4843-43EB-A7A7-67F7DDA6B3C4)]
 interface nsIDOMGeoPositionErrorCallback : nsISupports {
-  void handleEvent(in PositionError positionError);
+  void handleEvent(in GeolocationPositionError positionError);
 };
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -58,17 +58,17 @@
 #include "mozilla/dom/GetFilesHelper.h"
 #include "mozilla/dom/GeolocationBinding.h"
 #include "mozilla/dom/JSWindowActorService.h"
 #include "mozilla/dom/LocalStorageCommon.h"
 #include "mozilla/dom/MemoryReportRequest.h"
 #include "mozilla/dom/Notification.h"
 #include "mozilla/dom/PContentPermissionRequestParent.h"
 #include "mozilla/dom/PCycleCollectWithLogsParent.h"
-#include "mozilla/dom/PositionError.h"
+#include "mozilla/dom/GeolocationPositionError.h"
 #include "mozilla/dom/ServiceWorkerRegistrar.h"
 #include "mozilla/dom/power/PowerManagerService.h"
 #include "mozilla/dom/Permissions.h"
 #include "mozilla/dom/PresentationParent.h"
 #include "mozilla/dom/PPresentationParent.h"
 #include "mozilla/dom/PushNotifier.h"
 #include "mozilla/dom/quota/QuotaManagerService.h"
 #include "mozilla/dom/ServiceWorkerUtils.h"
@@ -4100,17 +4100,17 @@ mozilla::ipc::IPCResult ContentParent::R
 
 NS_IMETHODIMP
 ContentParent::HandleEvent(nsIDOMGeoPosition* postion) {
   Unused << SendGeolocationUpdate(postion);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-ContentParent::HandleEvent(PositionError* positionError) {
+ContentParent::HandleEvent(GeolocationPositionError* positionError) {
   Unused << SendGeolocationError(positionError->Code());
   return NS_OK;
 }
 
 nsConsoleService* ContentParent::GetConsoleService() {
   if (mConsoleService) {
     return mConsoleService.get();
   }
--- a/dom/system/linux/GpsdLocationProvider.cpp
+++ b/dom/system/linux/GpsdLocationProvider.cpp
@@ -6,17 +6,17 @@
 
 #include "GpsdLocationProvider.h"
 #include <errno.h>
 #include <gps.h>
 #include "MLSFallback.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/FloatingPoint.h"
 #include "mozilla/LazyIdleThread.h"
-#include "mozilla/dom/PositionErrorBinding.h"
+#include "mozilla/dom/GeolocationPositionErrorBinding.h"
 #include "nsGeoPosition.h"
 #include "nsProxyRelease.h"
 #include "nsThreadUtils.h"
 
 namespace mozilla {
 namespace dom {
 
 //
@@ -157,17 +157,17 @@ class GpsdLocationProvider::PollRunnable
   NS_IMETHOD Run() override {
     int err;
 
     switch (GPSD_API_MAJOR_VERSION) {
       case 5:
         err = PollLoop5();
         break;
       default:
-        err = PositionError_Binding::POSITION_UNAVAILABLE;
+        err = GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
         break;
     }
 
     if (err) {
       NS_DispatchToMainThread(
           MakeAndAddRef<NotifyErrorRunnable>(mLocationProvider, err));
     }
 
@@ -272,34 +272,34 @@ class GpsdLocationProvider::PollRunnable
                             PR_Now() / PR_USEC_PER_MSEC)));
     }
 
     gps_stream(&gpsData, WATCH_DISABLE, NULL);
     gps_close(&gpsData);
 
     return err;
 #else
-    return PositionError_Binding::POSITION_UNAVAILABLE;
+    return GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
 #endif  // GPSD_MAJOR_API_VERSION
   }
 
   static int ErrnoToError(int aErrno) {
     switch (aErrno) {
       case EACCES:
         MOZ_FALLTHROUGH;
       case EPERM:
         MOZ_FALLTHROUGH;
       case EROFS:
-        return PositionError_Binding::PERMISSION_DENIED;
+        return GeolocationPositionError_Binding::PERMISSION_DENIED;
       case ETIME:
         MOZ_FALLTHROUGH;
       case ETIMEDOUT:
-        return PositionError_Binding::TIMEOUT;
+        return GeolocationPositionError_Binding::TIMEOUT;
       default:
-        return PositionError_Binding::POSITION_UNAVAILABLE;
+        return GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
     }
   }
 
  private:
   nsMainThreadPtrHandle<GpsdLocationProvider> mLocationProvider;
   Atomic<bool> mRunning;
 };
 
--- a/dom/system/mac/CoreLocationLocationProvider.mm
+++ b/dom/system/mac/CoreLocationLocationProvider.mm
@@ -9,17 +9,17 @@
 #include "nsGeoPosition.h"
 #include "nsIConsoleService.h"
 #include "nsServiceManagerUtils.h"
 #include "CoreLocationLocationProvider.h"
 #include "nsCocoaFeatures.h"
 #include "prtime.h"
 #include "mozilla/FloatingPoint.h"
 #include "mozilla/Telemetry.h"
-#include "mozilla/dom/PositionErrorBinding.h"
+#include "mozilla/dom/GeolocationPositionErrorBinding.h"
 #include "MLSFallback.h"
 
 #include <CoreLocation/CLError.h>
 #include <CoreLocation/CLLocation.h>
 #include <CoreLocation/CLLocationManager.h>
 #include <CoreLocation/CLLocationManagerDelegate.h>
 
 #include <objc/objc.h>
@@ -57,17 +57,17 @@ static const CLLocationAccuracy kDEFAULT
   NS_ENSURE_TRUE_VOID(console);
 
   NSString* message =
       [@"Failed to acquire position: " stringByAppendingString:[aError localizedDescription]];
 
   console->LogStringMessage(NS_ConvertUTF8toUTF16([message UTF8String]).get());
 
   if ([aError code] == kCLErrorDenied) {
-    mProvider->NotifyError(dom::PositionError_Binding::PERMISSION_DENIED);
+    mProvider->NotifyError(dom::GeolocationPositionError_Binding::PERMISSION_DENIED);
     return;
   }
 
   // The CL provider does not fallback to GeoIP, so use NetworkGeolocationProvider for this.
   // The concept here is: on error, hand off geolocation to MLS, which will then report
   // back a location or error.
   mProvider->CreateMLSFallbackProvider();
 }
--- a/dom/system/windows/WindowsLocationProvider.cpp
+++ b/dom/system/windows/WindowsLocationProvider.cpp
@@ -7,17 +7,17 @@
 #include "WindowsLocationProvider.h"
 #include "nsGeoPosition.h"
 #include "nsComponentManagerUtils.h"
 #include "prtime.h"
 #include "MLSFallback.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/FloatingPoint.h"
 #include "mozilla/Telemetry.h"
-#include "mozilla/dom/PositionErrorBinding.h"
+#include "mozilla/dom/GeolocationPositionErrorBinding.h"
 
 namespace mozilla {
 namespace dom {
 
 NS_IMPL_ISUPPORTS(WindowsLocationProvider::MLSUpdate, nsIGeolocationUpdate);
 
 WindowsLocationProvider::MLSUpdate::MLSUpdate(nsIGeolocationUpdate* aCallback)
     : mCallback(aCallback) {}
@@ -116,21 +116,21 @@ LocationEvent::OnStatusChanged(REFIID aR
     return S_OK;
   }
 
   // Cannot watch location by MLS provider.  We must return error by
   // Location API.
   uint16_t err;
   switch (aStatus) {
     case REPORT_ACCESS_DENIED:
-      err = PositionError_Binding::PERMISSION_DENIED;
+      err = GeolocationPositionError_Binding::PERMISSION_DENIED;
       break;
     case REPORT_NOT_SUPPORTED:
     case REPORT_ERROR:
-      err = PositionError_Binding::POSITION_UNAVAILABLE;
+      err = GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
       break;
     default:
       return S_OK;
   }
   nsCOMPtr<nsIGeolocationUpdate> callback(mCallback);
   callback->NotifyError(err);
   return S_OK;
 }
--- a/dom/tests/mochitest/general/test_interfaces.js
+++ b/dom/tests/mochitest/general/test_interfaces.js
@@ -407,16 +407,24 @@ var interfaceNamesInGlobalScope = [
   { name: "GamepadHapticActuator", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "GamepadLightIndicator", insecureContext: false, disabled: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "GamepadPose", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "GamepadTouch", insecureContext: false, disabled: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
+  { name: "Geolocation", insecureContext: true },
+  // IMPORTANT: Do not change this list without review from a DOM peer!
+  { name: "GeolocationCoordinates", insecureContext: false },
+  // IMPORTANT: Do not change this list without review from a DOM peer!
+  { name: "GeolocationPosition", insecureContext: false },
+  // IMPORTANT: Do not change this list without review from a DOM peer!
+  { name: "GeolocationPositionError", insecureContext: true },
+  // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "HashChangeEvent", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "Headers", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "History", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
   { name: "HTMLAllCollection", insecureContext: true },
   // IMPORTANT: Do not change this list without review from a DOM peer!
--- a/dom/webidl/Geolocation.webidl
+++ b/dom/webidl/Geolocation.webidl
@@ -11,27 +11,26 @@
  */
 
 dictionary PositionOptions {
   boolean enableHighAccuracy = false;
   [Clamp] unsigned long timeout = 0x7fffffff;
   [Clamp] unsigned long maximumAge = 0;
 };
 
-[NoInterfaceObject,
- Exposed=Window]
+[Exposed=Window]
 interface Geolocation {
   [Throws, NeedsCallerType]
   void getCurrentPosition(PositionCallback successCallback,
                           optional PositionErrorCallback? errorCallback = null,
                           optional PositionOptions options = {});
 
   [Throws, NeedsCallerType]
   long watchPosition(PositionCallback successCallback,
                      optional PositionErrorCallback? errorCallback = null,
                      optional PositionOptions options = {});
 
   void clearWatch(long watchId);
 };
 
-callback PositionCallback = void (Position position);
+callback PositionCallback = void (GeolocationPosition position);
 
-callback PositionErrorCallback = void (PositionError positionError);
+callback PositionErrorCallback = void (GeolocationPositionError positionError);
rename from dom/webidl/Coordinates.webidl
rename to dom/webidl/GeolocationCoordinates.webidl
--- a/dom/webidl/Coordinates.webidl
+++ b/dom/webidl/GeolocationCoordinates.webidl
@@ -5,19 +5,18 @@
  *
  * The origin of this IDL file is
  * http://www.w3.org/TR/geolocation-API
  *
  * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
  * liability, trademark and document use rules apply.
  */
 
-[NoInterfaceObject,
- Exposed=Window]
-interface Coordinates {
+[Exposed=Window, SecureContext]
+interface GeolocationCoordinates {
   readonly attribute double latitude;
   readonly attribute double longitude;
   readonly attribute double? altitude;
   readonly attribute double accuracy;
   readonly attribute double? altitudeAccuracy;
   readonly attribute double? heading;
   readonly attribute double? speed;
 };
rename from dom/webidl/Position.webidl
rename to dom/webidl/GeolocationPosition.webidl
--- a/dom/webidl/Position.webidl
+++ b/dom/webidl/GeolocationPosition.webidl
@@ -5,14 +5,13 @@
  *
  * The origin of this IDL file is
  * http://www.w3.org/TR/geolocation-API
  *
  * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
  * liability, trademark and document use rules apply.
  */
 
-[NoInterfaceObject,
- Exposed=Window]
-interface Position {
-  readonly attribute Coordinates coords;
+[Exposed=Window, SecureContext]
+interface GeolocationPosition {
+  readonly attribute GeolocationCoordinates coords;
   readonly attribute DOMTimeStamp timestamp;
 };
rename from dom/webidl/PositionError.webidl
rename to dom/webidl/GeolocationPositionError.webidl
--- a/dom/webidl/PositionError.webidl
+++ b/dom/webidl/GeolocationPositionError.webidl
@@ -5,17 +5,16 @@
  *
  * The origin of this IDL file is
  * http://www.w3.org/TR/geolocation-API
  *
  * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
  * liability, trademark and document use rules apply.
  */
 
-[NoInterfaceObject,
- Exposed=Window]
-interface PositionError {
+[Exposed=Window]
+interface GeolocationPositionError {
   const unsigned short PERMISSION_DENIED = 1;
   const unsigned short POSITION_UNAVAILABLE = 2;
   const unsigned short TIMEOUT = 3;
   readonly attribute unsigned short code;
   readonly attribute DOMString message;
 };
--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -65,17 +65,17 @@ with Files("ClipboardEvent.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
 with Files("ConstantSourceNode.webidl"):
     BUG_COMPONENT = ("Core", "Web Audio")
 
 with Files("ConvolverNode.webidl"):
     BUG_COMPONENT = ("Core", "Web Audio")
 
-with Files("Coordinates.webidl"):
+with Files("GeolocationCoordinates.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Geolocation")
 
 with Files("Crypto.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Security")
 
 with Files("Device*"):
     BUG_COMPONENT = ("Core", "DOM: Device Interfaces")
 
@@ -236,17 +236,17 @@ with Files("PeriodicWave.webidl"):
     BUG_COMPONENT = ("Core", "Web Audio")
 
 with Files("PointerEvent.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
 with Files("PopStateEvent.webidl*"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
-with Files("Position*"):
+with Files("GeolocationPosition*"):
     BUG_COMPONENT = ("Core", "DOM: Geolocation")
 
 with Files("ProfileTimelineMarker.webidl"):
     BUG_COMPONENT = ("DevTools", "Performance Tools (Profiler/Timeline)")
 
 with Files("ProgressEvent.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
@@ -423,17 +423,16 @@ WEBIDL_FILES = [
     'Clipboard.webidl',
     'ClipboardEvent.webidl',
     'CommandEvent.webidl',
     'Comment.webidl',
     'CompositionEvent.webidl',
     'Console.webidl',
     'ConstantSourceNode.webidl',
     'ConvolverNode.webidl',
-    'Coordinates.webidl',
     'CreateOfferRequest.webidl',
     'CredentialManagement.webidl',
     'Crypto.webidl',
     'CSPDictionaries.webidl',
     'CSPReport.webidl',
     'CSS.webidl',
     'CSSAnimation.webidl',
     'CSSConditionRule.webidl',
@@ -518,16 +517,19 @@ WEBIDL_FILES = [
     'GainNode.webidl',
     'Gamepad.webidl',
     'GamepadHapticActuator.webidl',
     'GamepadLightIndicator.webidl',
     'GamepadPose.webidl',
     'GamepadServiceTest.webidl',
     'GamepadTouch.webidl',
     'Geolocation.webidl',
+    'GeolocationCoordinates.webidl',
+    'GeolocationPosition.webidl',
+    'GeolocationPositionError.webidl',
     'GeometryUtils.webidl',
     'GetUserMediaRequest.webidl',
     'Grid.webidl',
     'Headers.webidl',
     'History.webidl',
     'HTMLAllCollection.webidl',
     'HTMLAnchorElement.webidl',
     'HTMLAreaElement.webidl',
@@ -725,18 +727,16 @@ WEBIDL_FILES = [
     'PerformanceServerTiming.webidl',
     'PerformanceTiming.webidl',
     'PeriodicWave.webidl',
     'Permissions.webidl',
     'PermissionStatus.webidl',
     'Plugin.webidl',
     'PluginArray.webidl',
     'PointerEvent.webidl',
-    'Position.webidl',
-    'PositionError.webidl',
     'Presentation.webidl',
     'PresentationAvailability.webidl',
     'PresentationConnection.webidl',
     'PresentationConnectionList.webidl',
     'PresentationReceiver.webidl',
     'PresentationRequest.webidl',
     'ProcessingInstruction.webidl',
     'ProfileTimelineMarker.webidl',
--- a/testing/web-platform/meta/geolocation-API/getCurrentPosition_IDL.https.html.ini
+++ b/testing/web-platform/meta/geolocation-API/getCurrentPosition_IDL.https.html.ini
@@ -9,10 +9,9 @@
       TIMEOUT
 
   [getCurrentPosition error callback tests]
     expected:
       if os == "android": PASS
       TIMEOUT
 
   [GeolocationPositionError toString]
-    expected: FAIL
 
--- a/testing/web-platform/meta/geolocation-API/idlharness.https.window.js.ini
+++ b/testing/web-platform/meta/geolocation-API/idlharness.https.window.js.ini
@@ -1,136 +1,91 @@
 [idlharness.https.window.html]
   [GeolocationPositionError interface: constant PERMISSION_DENIED on interface object]
-    expected: FAIL
 
   [GeolocationPositionError interface: existence and properties of interface prototype object's @@unscopables property]
-    expected: FAIL
 
   [GeolocationPositionError interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute accuracy]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute latitude]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute heading]
-    expected: FAIL
 
   [GeolocationCoordinates interface object name]
-    expected: FAIL
 
   [GeolocationPositionError interface object length]
-    expected: FAIL
 
   [Geolocation interface: existence and properties of interface prototype object]
-    expected: FAIL
 
   [GeolocationPositionError interface: constant PERMISSION_DENIED on interface prototype object]
-    expected: FAIL
 
   [Geolocation interface: existence and properties of interface prototype object's @@unscopables property]
-    expected: FAIL
 
   [Geolocation interface: existence and properties of interface object]
-    expected: FAIL
 
   [GeolocationPositionError interface: constant POSITION_UNAVAILABLE on interface object]
-    expected: FAIL
 
   [GeolocationPositionError interface object name]
-    expected: FAIL
 
   [GeolocationPositionError interface: constant TIMEOUT on interface prototype object]
-    expected: FAIL
 
   [GeolocationPositionError interface: attribute message]
-    expected: FAIL
 
   [GeolocationPosition interface object name]
-    expected: FAIL
 
   [GeolocationPosition interface: existence and properties of interface object]
-    expected: FAIL
 
   [GeolocationPositionError interface: constant POSITION_UNAVAILABLE on interface prototype object]
-    expected: FAIL
 
   [GeolocationCoordinates interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL
 
   [GeolocationCoordinates interface object length]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute altitudeAccuracy]
-    expected: FAIL
 
   [GeolocationPosition interface: existence and properties of interface prototype object's @@unscopables property]
-    expected: FAIL
 
   [Geolocation must be primary interface of navigator.geolocation]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute altitude]
-    expected: FAIL
 
   [Geolocation interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute speed]
-    expected: FAIL
 
   [GeolocationPositionError interface: existence and properties of interface prototype object]
-    expected: FAIL
 
   [GeolocationCoordinates interface: existence and properties of interface object]
-    expected: FAIL
 
   [Geolocation interface: operation watchPosition(PositionCallback, PositionErrorCallback, PositionOptions)]
-    expected: FAIL
 
   [GeolocationPosition interface: attribute coords]
-    expected: FAIL
 
   [Geolocation interface: operation clearWatch(long)]
-    expected: FAIL
 
   [Geolocation interface object length]
-    expected: FAIL
 
   [GeolocationCoordinates interface: attribute longitude]
-    expected: FAIL
 
   [GeolocationCoordinates interface: existence and properties of interface prototype object]
-    expected: FAIL
 
   [GeolocationCoordinates interface: existence and properties of interface prototype object's @@unscopables property]
-    expected: FAIL
 
   [GeolocationPosition interface: existence and properties of interface prototype object]
-    expected: FAIL
 
   [GeolocationPositionError interface: constant TIMEOUT on interface object]
-    expected: FAIL
 
   [GeolocationPositionError interface: attribute code]
-    expected: FAIL
 
   [Geolocation interface: operation getCurrentPosition(PositionCallback, PositionErrorCallback, PositionOptions)]
-    expected: FAIL
 
   [GeolocationPosition interface: attribute timestamp]
-    expected: FAIL
 
   [GeolocationPosition interface object length]
-    expected: FAIL
 
   [Geolocation interface object name]
-    expected: FAIL
 
   [GeolocationPositionError interface: existence and properties of interface object]
-    expected: FAIL
 
   [GeolocationPosition interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL