Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/dom/geolocation/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 46 kB

Quelle Geolocation.cpp Sprache: C

/* -*- 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 "Geolocation.h"

#include "GeolocationIPCUtils.h"
#include "GeolocationSystem.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/CycleCollectedJSContext.h"  // for nsAutoMicroTask
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/GeolocationPositionError.h"
#include "mozilla/dom/GeolocationPositionErrorBinding.h"
#include "mozilla/glean/DomGeolocationMetrics.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "mozilla/StaticPrefs_geo.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Unused.h"
#include "mozilla/WeakPtr.h"
#include "mozilla/EventStateManager.h"
#include "nsComponentManagerUtils.h"
#include "nsContentPermissionHelper.h"
#include "nsContentUtils.h"
#include "nsGlobalWindowInner.h"
#include "mozilla/dom/Document.h"
#include "nsINamed.h"
#include "nsIObserverService.h"
#include "nsIPromptService.h"
#include "nsIScriptError.h"
#include "nsPIDOMWindow.h"
#include "nsServiceManagerUtils.h"
#include "nsThreadUtils.h"
#include "nsXULAppAPI.h"

class nsIPrincipal;

#ifdef MOZ_WIDGET_ANDROID
#  include "AndroidLocationProvider.h"
#endif

#ifdef MOZ_ENABLE_DBUS
#  include "mozilla/WidgetUtilsGtk.h"
#  include "GeoclueLocationProvider.h"
#  include "PortalLocationProvider.h"
#endif

#ifdef MOZ_WIDGET_COCOA
#  include "CoreLocationLocationProvider.h"
#endif

#ifdef XP_WIN
#  include "WindowsLocationProvider.h"
#endif

// Some limit to the number of get or watch geolocation requests
// that a window can make.
#define MAX_GEO_REQUESTS_PER_WINDOW 1500

// This preference allows to override the "secure context" by
// default policy.
#define PREF_GEO_SECURITY_ALLOWINSECURE "geo.security.allowinsecure"

using mozilla::Unused;  // <snicker>
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::dom::geolocation;

mozilla::LazyLogModule gGeolocationLog("Geolocation");

class nsGeolocationRequest final : public ContentPermissionRequestBase,
                                   public nsIGeolocationUpdate,
                                   public SupportsWeakPtr {
public:
  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_NSIGEOLOCATIONUPDATE

  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsGeolocationRequest,
                                           ContentPermissionRequestBase)

  nsGeolocationRequest(Geolocation* aLocator, GeoPositionCallback aCallback,
                       GeoPositionErrorCallback aErrorCallback,
                       UniquePtr<PositionOptions>&& aOptions,
                       nsIEventTarget* aMainThreadSerialEventTarget,
                       bool aWatchPositionRequest = false,
                       int32_t aWatchId = 0);

  // nsIContentPermissionRequest
  MOZ_CAN_RUN_SCRIPT NS_IMETHOD Cancel(void) override;
  MOZ_CAN_RUN_SCRIPT NS_IMETHOD Allow(JS::Handle<JS::Value> choices) override;
  NS_IMETHOD GetTypes(nsIArray** aTypes) override;

  void Shutdown();

  // MOZ_CAN_RUN_SCRIPT_BOUNDARY is OK here because we're always called from a
  // runnable.  Ideally nsIRunnable::Run and its overloads would just be
  // MOZ_CAN_RUN_SCRIPT and then we could be too...
  MOZ_CAN_RUN_SCRIPT_BOUNDARY
  void SendLocation(nsIDOMGeoPosition* aLocation);
  bool WantsHighAccuracy() {
    return !mShutdown && mOptions && mOptions->mEnableHighAccuracy;
  }
  void SetTimeoutTimer();
  void StopTimeoutTimer();
  MOZ_CAN_RUN_SCRIPT
  void NotifyErrorAndShutdown(uint16_t);
  using ContentPermissionRequestBase::GetPrincipal;
  nsIPrincipal* GetPrincipal();

  bool IsWatch() { return mIsWatchPositionRequest; }
  int32_t WatchId() { return mWatchId; }

  void SetPromptBehavior(
      geolocation::SystemGeolocationPermissionBehavior aBehavior) {
    mBehavior = aBehavior;
  }

private:
  virtual ~nsGeolocationRequest();

  class TimerCallbackHolder final : public nsITimerCallback, public nsINamed {
   public:
    NS_DECL_ISUPPORTS
    NS_DECL_NSITIMERCALLBACK

    explicit TimerCallbackHolder(nsGeolocationRequest* aRequest)
        : mRequest(aRequest) {}

    NS_IMETHOD GetName(nsACString& aName) override {
      aName.AssignLiteral("nsGeolocationRequest::TimerCallbackHolder");
      return NS_OK;
    }

   private:
    ~TimerCallbackHolder() = default;
    WeakPtr<nsGeolocationRequest> mRequest;
  };

  // Only called from a timer, so MOZ_CAN_RUN_SCRIPT_BOUNDARY ok for now.
  MOZ_CAN_RUN_SCRIPT_BOUNDARY void Notify();

  bool mIsWatchPositionRequest;

  nsCOMPtr<nsITimer> mTimeoutTimer;
  GeoPositionCallback mCallback;
  GeoPositionErrorCallback mErrorCallback;
  UniquePtr<PositionOptions> mOptions;

  RefPtr<Geolocation> mLocator;

  int32_t mWatchId;
  bool mShutdown;
  bool mSeenAnySignal = false;
  nsCOMPtr<nsIEventTarget> mMainThreadSerialEventTarget;

  SystemGeolocationPermissionBehavior mBehavior;
};

static UniquePtr<PositionOptions> CreatePositionOptionsCopy(
    const PositionOptions& aOptions) {
  UniquePtr<PositionOptions> geoOptions = MakeUnique<PositionOptions>();

  geoOptions->mEnableHighAccuracy = aOptions.mEnableHighAccuracy;
  geoOptions->mMaximumAge = aOptions.mMaximumAge;
  geoOptions->mTimeout = aOptions.mTimeout;

  return geoOptions;
}

class RequestSendLocationEvent : public Runnable {
public:
  RequestSendLocationEvent(nsIDOMGeoPosition* aPosition,
                           nsGeolocationRequest* aRequest)
      : mozilla::Runnable("RequestSendLocationEvent"),
        mPosition(aPosition),
        mRequest(aRequest) {}

  NS_IMETHOD Run() override {
    mRequest->SendLocation(mPosition);
    return NS_OK;
  }

private:
  nsCOMPtr<nsIDOMGeoPosition> mPosition;
  RefPtr<nsGeolocationRequest> mRequest;
  RefPtr<Geolocation> mLocator;
};

////////////////////////////////////////////////////
// nsGeolocationRequest
////////////////////////////////////////////////////

static nsPIDOMWindowInner* ConvertWeakReferenceToWindow(
    nsIWeakReference* aWeakPtr) {
  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(aWeakPtr);
  // This isn't usually safe, but here we're just extracting a raw pointer in
  // order to pass it to a base class constructor which will in turn convert it
  // into a strong pointer for us.
  nsPIDOMWindowInner* raw = window.get();
  return raw;
}

nsGeolocationRequest::nsGeolocationRequest(
    Geolocation* aLocator, GeoPositionCallback aCallback,
    GeoPositionErrorCallback aErrorCallback,
    UniquePtr<PositionOptions>&& aOptions,
    nsIEventTarget* aMainThreadSerialEventTarget, bool aWatchPositionRequest,
    int32_t aWatchId)
    : ContentPermissionRequestBase(
          aLocator->GetPrincipal(),
          ConvertWeakReferenceToWindow(aLocator->GetOwner()), "geo"_ns,
          "geolocation"_ns),
      mIsWatchPositionRequest(aWatchPositionRequest),
      mCallback(std::move(aCallback)),
      mErrorCallback(std::move(aErrorCallback)),
      mOptions(std::move(aOptions)),
      mLocator(aLocator),
      mWatchId(aWatchId),
      mShutdown(false),
      mMainThreadSerialEventTarget(aMainThreadSerialEventTarget),
      mBehavior(SystemGeolocationPermissionBehavior::NoPrompt) {}

nsGeolocationRequest::~nsGeolocationRequest() { StopTimeoutTimer(); }

NS_IMPL_QUERY_INTERFACE_CYCLE_COLLECTION_INHERITED(nsGeolocationRequest,
                                                   ContentPermissionRequestBase,
                                                   nsIGeolocationUpdate)

NS_IMPL_ADDREF_INHERITED(nsGeolocationRequest, ContentPermissionRequestBase)
NS_IMPL_RELEASE_INHERITED(nsGeolocationRequest, ContentPermissionRequestBase)
NS_IMPL_CYCLE_COLLECTION_WEAK_PTR_INHERITED(nsGeolocationRequest,
                                            ContentPermissionRequestBase,
                                            mCallback, mErrorCallback, mLocator)

void nsGeolocationRequest::Notify() {
  MOZ_LOG(gGeolocationLog, LogLevel::Debug, ("nsGeolocationRequest::Notify"));
  SetTimeoutTimer();
  NotifyErrorAndShutdown(GeolocationPositionError_Binding::TIMEOUT);
}

void nsGeolocationRequest::NotifyErrorAndShutdown(uint16_t aErrorCode) {
  MOZ_LOG(gGeolocationLog, LogLevel::Debug,
          ("nsGeolocationRequest::NotifyErrorAndShutdown with error code: %u",
           aErrorCode));
  MOZ_ASSERT(!mShutdown, "timeout after shutdown");
  if (!mIsWatchPositionRequest) {
    Shutdown();
    mLocator->RemoveRequest(this);
  }

  NotifyError(aErrorCode);
}

NS_IMETHODIMP
nsGeolocationRequest::Cancel() {
  if (mLocator->ClearPendingRequest(this)) {
    return NS_OK;
  }

  NotifyError(GeolocationPositionError_Binding::PERMISSION_DENIED);
  return NS_OK;
}

/**
* When the promise for the cancel dialog is resolved or rejected, we should
* stop waiting for permission.  If it was granted then the
* SystemGeolocationPermissionRequest should already be resolved, so we do
* nothing.  Otherwise, we were either cancelled or got an error, so we cancel
* the SystemGeolocationPermissionRequest.
*/
class CancelSystemGeolocationPermissionRequest : public PromiseNativeHandler {
public:
  NS_DECL_ISUPPORTS

  explicit CancelSystemGeolocationPermissionRequest(
      SystemGeolocationPermissionRequest* aRequest)
      : mRequest(aRequest) {}

  MOZ_CAN_RUN_SCRIPT_BOUNDARY
  void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
                        ErrorResult& aRv) override {
    mRequest->Stop();
  }

  MOZ_CAN_RUN_SCRIPT_BOUNDARY
  void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
                        ErrorResult& aRv) override {
    mRequest->Stop();
  }

private:
  ~CancelSystemGeolocationPermissionRequest() = default;
  RefPtr<SystemGeolocationPermissionRequest> mRequest;
};

NS_IMPL_ISUPPORTS0(CancelSystemGeolocationPermissionRequest)

/* static */
void Geolocation::ReallowWithSystemPermissionOrCancel(
    BrowsingContext* aBrowsingContext,
    geolocation::ParentRequestResolver&& aResolver) {
  // Make sure we don't return without responding to the geolocation request.
  auto denyPermissionOnError =
      MakeScopeExit([&aResolver]() MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA {
        aResolver(GeolocationPermissionStatus::Error);
      });

  NS_ENSURE_TRUE_VOID(aBrowsingContext);

  nsCOMPtr<nsIStringBundle> bundle;
  nsCOMPtr<nsIStringBundleService> sbs =
      do_GetService(NS_STRINGBUNDLE_CONTRACTID);
  NS_ENSURE_TRUE_VOID(sbs);

  sbs->CreateBundle("chrome://browser/locale/browser.properties",
                    getter_AddRefs(bundle));
  NS_ENSURE_TRUE_VOID(bundle);

  nsAutoString title;
  nsresult rv =
      bundle->GetStringFromName("geolocation.systemSettingsTitle", title);
  NS_ENSURE_SUCCESS_VOID(rv);

  nsAutoString brandName;
  rv = nsContentUtils::GetLocalizedString(nsContentUtils::eBRAND_PROPERTIES,
                                          "brandShortName", brandName);
  NS_ENSURE_SUCCESS_VOID(rv);
  AutoTArray<nsString, 1> formatParams;
  formatParams.AppendElement(brandName);
  nsAutoString message;
  rv = bundle->FormatStringFromName("geolocation.systemSettingsMessage",
                                    formatParams, message);
  NS_ENSURE_SUCCESS_VOID(rv);

  // We MUST do this because aResolver is moved below.
  denyPermissionOnError.release();

  RefPtr<SystemGeolocationPermissionRequest> permissionRequest =
      geolocation::RequestLocationPermissionFromUser(aBrowsingContext,
                                                     std::move(aResolver));
  NS_ENSURE_TRUE_VOID(permissionRequest);

  auto cancelRequestOnError = MakeScopeExit([&]() {
    // Stop waiting for the system permission and just leave it up to the user.
    permissionRequest->Stop();
  });

  nsCOMPtr<nsIPromptService> promptSvc =
      do_GetService("@mozilla.org/prompter;1", &rv);
  NS_ENSURE_SUCCESS_VOID(rv);

  // The dialog should include a cancel button if Gecko is prompting the user
  // for system permission.  It should have no buttons if the OS will be
  // doing the prompting.
  bool geckoWillPrompt =
      GetLocationOSPermission() ==
      geolocation::SystemGeolocationPermissionBehavior::GeckoWillPromptUser;
  // This combination of flags removes all buttons and adds a spinner to the
  // title.
  const auto kSpinnerNoButtonFlags =
      nsIPromptService::BUTTON_NONE | nsIPromptService::SHOW_SPINNER;
  // This combination of flags indicates there is only one button labeled
  // "Cancel".
  const auto kCancelButtonFlags =
      nsIPromptService::BUTTON_TITLE_CANCEL * nsIPromptService::BUTTON_POS_0;
  RefPtr<mozilla::dom::Promise> tabBlockingDialogPromise;
  rv = promptSvc->AsyncConfirmEx(
      aBrowsingContext, nsIPromptService::MODAL_TYPE_TAB, title.get(),
      message.get(),
      geckoWillPrompt ? kCancelButtonFlags : kSpinnerNoButtonFlags, nullptr,
      nullptr, nullptr, nullptr, false, JS::UndefinedHandleValue,
      getter_AddRefs(tabBlockingDialogPromise));
  NS_ENSURE_SUCCESS_VOID(rv);
  MOZ_ASSERT(tabBlockingDialogPromise);

  // If the tab blocking dialog promise is resolved or rejected then the dialog
  // is no longer visible so we should stop waiting for permission, whether it
  // was granted or not.
  tabBlockingDialogPromise->AppendNativeHandler(
      new CancelSystemGeolocationPermissionRequest(permissionRequest));

  cancelRequestOnError.release();
}

NS_IMETHODIMP
nsGeolocationRequest::Allow(JS::Handle<JS::Value> aChoices) {
  MOZ_ASSERT(aChoices.isUndefined());

  if (mLocator->ClearPendingRequest(this)) {
    return NS_OK;
  }

  if (mBehavior != SystemGeolocationPermissionBehavior::NoPrompt) {
    // Asynchronously present the system dialog or open system preferences
    // (RequestGeolocationPermissionFromUser will know which to do), and wait
    // for the permission to change or the request to be canceled.  If the
    // permission is (maybe) granted then it will call Allow again.  It actually
    // will also re-call Allow if the permission is denied, in order to get the
    // "denied permission" behavior.
    mBehavior = SystemGeolocationPermissionBehavior::NoPrompt;
    RefPtr<BrowsingContext> browsingContext = mWindow->GetBrowsingContext();
    if (ContentChild* cc = ContentChild::GetSingleton()) {
      cc->SendRequestGeolocationPermissionFromUser(
          browsingContext,
          [self = RefPtr{this}](GeolocationPermissionStatus aResult)
              MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA {
                self->Allow(JS::UndefinedHandleValue);
              },
          [self = RefPtr{this}](mozilla::ipc::ResponseRejectReason aReason)
              MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA {
                self->Allow(JS::UndefinedHandleValue);
              });
      return NS_OK;
    }

    Geolocation::ReallowWithSystemPermissionOrCancel(
        browsingContext,
        [self = RefPtr{this}](GeolocationPermissionStatus aResult)
            MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA {
              self->Allow(JS::UndefinedHandleValue);
            });
    return NS_OK;
  }

  RefPtr<nsGeolocationService> gs =
      nsGeolocationService::GetGeolocationService();

  bool canUseCache = false;
  CachedPositionAndAccuracy lastPosition = gs->GetCachedPosition();
  if (lastPosition.position) {
    EpochTimeStamp cachedPositionTime_ms;
    lastPosition.position->GetTimestamp(&cachedPositionTime_ms);
    // check to see if we can use a cached value
    // if the user has specified a maximumAge, return a cached value.
    if (mOptions && mOptions->mMaximumAge > 0) {
      uint32_t maximumAge_ms = mOptions->mMaximumAge;
      bool isCachedWithinRequestedAccuracy =
          WantsHighAccuracy() <= lastPosition.isHighAccuracy;
      bool isCachedWithinRequestedTime =
          EpochTimeStamp(PR_Now() / PR_USEC_PER_MSEC - maximumAge_ms) <=
          cachedPositionTime_ms;
      canUseCache =
          isCachedWithinRequestedAccuracy && isCachedWithinRequestedTime;
    }
  }

  gs->UpdateAccuracy(WantsHighAccuracy());
  if (canUseCache) {
    // okay, we can return a cached position
    // getCurrentPosition requests serviced by the cache
    // will now be owned by the RequestSendLocationEvent
    Update(lastPosition.position);

    // After Update is called, getCurrentPosition finishes its job.
    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(GeolocationPositionError_Binding::TIMEOUT);
      return NS_OK;
    }
  }

  // Non-cached location request
  bool allowedRequest = mIsWatchPositionRequest || !canUseCache;
  if (allowedRequest) {
    // let the locator know we're pending
    // we will now be owned by the locator
    mLocator->NotifyAllowedRequest(this);
  }

  // Kick off the geo device, if it isn't already running
  nsresult rv = gs->StartDevice();

  if (NS_FAILED(rv)) {
    if (allowedRequest) {
      mLocator->RemoveRequest(this);
    }
    // Location provider error
    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
    return NS_OK;
  }

  SetTimeoutTimer();

  return NS_OK;
}

void nsGeolocationRequest::SetTimeoutTimer() {
  MOZ_ASSERT(!mShutdown, "set timeout after shutdown");

  StopTimeoutTimer();

  if (mOptions && mOptions->mTimeout != 0 && mOptions->mTimeout != 0x7fffffff) {
    RefPtr<TimerCallbackHolder> holder = new TimerCallbackHolder(this);
    NS_NewTimerWithCallback(getter_AddRefs(mTimeoutTimer), holder,
                            mOptions->mTimeout, nsITimer::TYPE_ONE_SHOT);
  }
}

void nsGeolocationRequest::StopTimeoutTimer() {
  if (mTimeoutTimer) {
    mTimeoutTimer->Cancel();
    mTimeoutTimer = nullptr;
  }
}

void nsGeolocationRequest::SendLocation(nsIDOMGeoPosition* aPosition) {
  if (mShutdown) {
    // Ignore SendLocationEvents issued before we were cleared.
    return;
  }

  if (mOptions && mOptions->mMaximumAge > 0) {
    EpochTimeStamp positionTime_ms;
    aPosition->GetTimestamp(&positionTime_ms);
    const uint32_t maximumAge_ms = mOptions->mMaximumAge;
    const bool isTooOld = EpochTimeStamp(PR_Now() / PR_USEC_PER_MSEC -
                                         maximumAge_ms) > positionTime_ms;
    if (isTooOld) {
      return;
    }
  }

  RefPtr<mozilla::dom::GeolocationPosition> wrapped;

  if (aPosition) {
    nsCOMPtr<nsIDOMGeoPositionCoords> coords;
    aPosition->GetCoords(getter_AddRefs(coords));
    if (coords) {
      wrapped = new mozilla::dom::GeolocationPosition(ToSupports(mLocator),
                                                      aPosition);
    }
  }

  if (!wrapped) {
    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
    return;
  }

  if (!mIsWatchPositionRequest) {
    // Cancel timer and position updates in case the position
    // callback spins the event loop
    Shutdown();
  }

  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  obs->NotifyObservers(wrapped, "geolocation-position-events",
                       u"location-updated");

  nsAutoMicroTask mt;
  if (mCallback.HasWebIDLCallback()) {
    RefPtr<PositionCallback> callback = mCallback.GetWebIDLCallback();

    MOZ_ASSERT(callback);
    callback->Call(*wrapped);
  } else {
    nsIDOMGeoPositionCallback* callback = mCallback.GetXPCOMCallback();
    MOZ_ASSERT(callback);
    callback->HandleEvent(aPosition);
  }

  if (mIsWatchPositionRequest && !mShutdown) {
    SetTimeoutTimer();
  }
  MOZ_ASSERT(mShutdown || mIsWatchPositionRequest,
             "non-shutdown getCurrentPosition request after callback!");
}

nsIPrincipal* nsGeolocationRequest::GetPrincipal() {
  if (!mLocator) {
    return nullptr;
  }
  return mLocator->GetPrincipal();
}

NS_IMETHODIMP
nsGeolocationRequest::Update(nsIDOMGeoPosition* aPosition) {
  if (!mSeenAnySignal) {
    mSeenAnySignal = true;
    glean::geolocation::request_result
        .EnumGet(glean::geolocation::RequestResultLabel::eSuccess)
        .Add();
  }
  nsCOMPtr<nsIRunnable> ev = new RequestSendLocationEvent(aPosition, this);
  mMainThreadSerialEventTarget->Dispatch(ev.forget());
  return NS_OK;
}

static glean::geolocation::RequestResultLabel MapErrorToLabel(
    uint16_t aErrorCode) {
  using Label = glean::geolocation::RequestResultLabel;
  switch (aErrorCode) {
    case GeolocationPositionError_Binding::PERMISSION_DENIED:
      return Label::ePermissionDenied;
    case GeolocationPositionError_Binding::POSITION_UNAVAILABLE:
      return Label::ePositionUnavailable;
    case GeolocationPositionError_Binding::TIMEOUT:
      return Label::eTimeout;
    default:
      MOZ_CRASH("Unknown geolocation error label");
      return Label::ePositionUnavailable;
  }
}

NS_IMETHODIMP
nsGeolocationRequest::NotifyError(uint16_t aErrorCode) {
  MOZ_LOG(
      gGeolocationLog, LogLevel::Debug,
      ("nsGeolocationRequest::NotifyError with error code: %u", aErrorCode));
  MOZ_ASSERT(NS_IsMainThread());
  if (!mSeenAnySignal) {
    mSeenAnySignal = true;
    glean::geolocation::request_result.EnumGet(MapErrorToLabel(aErrorCode))
        .Add();
  }
  RefPtr<GeolocationPositionError> positionError =
      new GeolocationPositionError(mLocator, static_cast<int16_t>(aErrorCode));
  positionError->NotifyCallback(mErrorCallback);
  return NS_OK;
}

void nsGeolocationRequest::Shutdown() {
  MOZ_ASSERT(!mShutdown, "request shutdown twice");
  mShutdown = true;

  StopTimeoutTimer();

  // If there are no other high accuracy requests, the geolocation service will
  // notify the provider to switch to the default accuracy.
  if (mOptions && mOptions->mEnableHighAccuracy) {
    RefPtr<nsGeolocationService> gs =
        nsGeolocationService::GetGeolocationService();
    if (gs) {
      gs->UpdateAccuracy();
    }
  }
}

NS_IMETHODIMP
nsGeolocationRequest::GetTypes(nsIArray** aTypes) {
  AutoTArray<nsString, 2> options;

  switch (mBehavior) {
    case SystemGeolocationPermissionBehavior::SystemWillPromptUser:
      options.AppendElement(u"sysdlg"_ns);
      break;
    case SystemGeolocationPermissionBehavior::GeckoWillPromptUser:
      options.AppendElement(u"syssetting"_ns);
      break;
    default:
      break;
  }
  return nsContentPermissionUtils::CreatePermissionArray(mType, options,
                                                         aTypes);
}

////////////////////////////////////////////////////
// nsGeolocationRequest::TimerCallbackHolder
////////////////////////////////////////////////////

NS_IMPL_ISUPPORTS(nsGeolocationRequest::TimerCallbackHolder, nsITimerCallback,
                  nsINamed)

NS_IMETHODIMP
nsGeolocationRequest::TimerCallbackHolder::Notify(nsITimer*) {
  if (mRequest && mRequest->mLocator) {
    RefPtr<nsGeolocationRequest> request(mRequest);
    request->Notify();
  }

  return NS_OK;
}

////////////////////////////////////////////////////
// nsGeolocationService
////////////////////////////////////////////////////
NS_INTERFACE_MAP_BEGIN(nsGeolocationService)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIGeolocationUpdate)
  NS_INTERFACE_MAP_ENTRY(nsIGeolocationUpdate)
  NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_END

NS_IMPL_ADDREF(nsGeolocationService)
NS_IMPL_RELEASE(nsGeolocationService)

nsresult nsGeolocationService::Init() {
  if (!StaticPrefs::geo_enabled()) {
    return NS_ERROR_FAILURE;
  }

  if (XRE_IsContentProcess()) {
    return NS_OK;
  }

  // geolocation service can be enabled -> now register observer
  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  if (!obs) {
    return NS_ERROR_FAILURE;
  }

  obs->AddObserver(this, "xpcom-shutdown", false);

#ifdef MOZ_WIDGET_ANDROID
  mProvider = new AndroidLocationProvider();
#endif

#ifdef MOZ_WIDGET_GTK
#  ifdef MOZ_ENABLE_DBUS
  if (!mProvider && widget::ShouldUsePortal(widget::PortalKind::Location)) {
    mProvider = new PortalLocationProvider();
    MOZ_LOG(gGeolocationLog, LogLevel::Debug,
            ("Selected PortalLocationProvider"));
    glean::geolocation::linux_provider
        .EnumGet(glean::geolocation::LinuxProviderLabel::ePortal)
        .Set(true);
  }

  if (!mProvider && StaticPrefs::geo_provider_use_geoclue()) {
    nsCOMPtr<nsIGeolocationProvider> gcProvider = new GeoclueLocationProvider();
    MOZ_LOG(gGeolocationLog, LogLevel::Debug,
            ("Checking GeoclueLocationProvider"));
    // The Startup() method will only succeed if Geoclue is available on D-Bus
    if (NS_SUCCEEDED(gcProvider->Startup())) {
      gcProvider->Shutdown();
      mProvider = std::move(gcProvider);
      MOZ_LOG(gGeolocationLog, LogLevel::Debug,
              ("Selected GeoclueLocationProvider"));
      glean::geolocation::linux_provider
          .EnumGet(glean::geolocation::LinuxProviderLabel::eGeoclue)
          .Set(true);
    }
  }
#  endif
#endif

#ifdef MOZ_WIDGET_COCOA
  if (Preferences::GetBool("geo.provider.use_corelocation", true)) {
    mProvider = new CoreLocationLocationProvider();
  }
#endif

#ifdef XP_WIN
  if (Preferences::GetBool("geo.provider.ms-windows-location", false)) {
    mProvider = new WindowsLocationProvider();
  }
#endif

  if (Preferences::GetBool("geo.provider.use_mls", false)) {
    mProvider = do_CreateInstance("@mozilla.org/geolocation/mls-provider;1");
  }

  // Override platform-specific providers with the default (network)
  // provider while testing. Our tests are currently not meant to exercise
  // the provider, and some tests rely on the network provider being used.
  // "geo.provider.testing" is always set for all plain and browser chrome
  // mochitests, and also for xpcshell tests.
  if (!mProvider || Preferences::GetBool("geo.provider.testing", false)) {
    nsCOMPtr<nsIGeolocationProvider> geoTestProvider =
        do_GetService(NS_GEOLOCATION_PROVIDER_CONTRACTID);

    if (geoTestProvider) {
      mProvider = geoTestProvider;
    }
  }

  return NS_OK;
}

nsGeolocationService::~nsGeolocationService() = default;

NS_IMETHODIMP
nsGeolocationService::Observe(nsISupports* aSubject, const char* aTopic,
                              const char16_t* aData) {
  if (!strcmp("xpcom-shutdown", aTopic)) {
    nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
    if (obs) {
      obs->RemoveObserver(this, "xpcom-shutdown");
    }

    for (uint32_t i = 0; i < mGeolocators.Length(); i++) {
      mGeolocators[i]->Shutdown();
    }
    StopDevice();

    return NS_OK;
  }

  if (!strcmp("timer-callback", aTopic)) {
    // decide if we can close down the service.
    for (uint32_t i = 0; i < mGeolocators.Length(); i++)
      if (mGeolocators[i]->HasActiveCallbacks()) {
        SetDisconnectTimer();
        return NS_OK;
      }

    // okay to close up.
    StopDevice();
    Update(nullptr);
    return NS_OK;
  }

  return NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsGeolocationService::Update(nsIDOMGeoPosition* aSomewhere) {
  if (aSomewhere) {
    SetCachedPosition(aSomewhere);
  }

  for (uint32_t i = 0; i < mGeolocators.Length(); i++) {
    mGeolocators[i]->Update(aSomewhere);
  }

  return NS_OK;
}

NS_IMETHODIMP
nsGeolocationService::NotifyError(uint16_t aErrorCode) {
  MOZ_LOG(
      gGeolocationLog, LogLevel::Debug,
      ("nsGeolocationService::NotifyError with error code: %u", aErrorCode));
  // nsTArray doesn't have a constructors that takes a different-type TArray.
  nsTArray<RefPtr<Geolocation>> geolocators;
  geolocators.AppendElements(mGeolocators);
  for (uint32_t i = 0; i < geolocators.Length(); i++) {
    // MOZ_KnownLive because the stack array above keeps it alive.
    MOZ_KnownLive(geolocators[i])->NotifyError(aErrorCode);
  }
  return NS_OK;
}

void nsGeolocationService::SetCachedPosition(nsIDOMGeoPosition* aPosition) {
  mLastPosition.position = aPosition;
  mLastPosition.isHighAccuracy = mHigherAccuracy;
}

CachedPositionAndAccuracy nsGeolocationService::GetCachedPosition() {
  return mLastPosition;
}

nsresult nsGeolocationService::StartDevice() {
  if (!StaticPrefs::geo_enabled()) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  // We do not want to keep the geolocation devices online
  // indefinitely.
  // Close them down after a reasonable period of inactivivity.
  SetDisconnectTimer();

  if (XRE_IsContentProcess()) {
    ContentChild* cpc = ContentChild::GetSingleton();
    cpc->SendAddGeolocationListener(HighAccuracyRequested());
    return NS_OK;
  }

  // Start them up!
  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  if (!obs) {
    return NS_ERROR_FAILURE;
  }

  if (!mProvider) {
    return NS_ERROR_FAILURE;
  }

  nsresult rv;

  if (NS_FAILED(rv = mProvider->Startup()) ||
      NS_FAILED(rv = mProvider->Watch(this))) {
    NotifyError(GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
    return rv;
  }

  obs->NotifyObservers(mProvider, "geolocation-device-events", u"starting");

  return NS_OK;
}

void nsGeolocationService::SetDisconnectTimer() {
  if (!mDisconnectTimer) {
    mDisconnectTimer = NS_NewTimer();
  } else {
    mDisconnectTimer->Cancel();
  }

  mDisconnectTimer->Init(this, StaticPrefs::geo_timeout(),
                         nsITimer::TYPE_ONE_SHOT);
}

bool nsGeolocationService::HighAccuracyRequested() {
  for (uint32_t i = 0; i < mGeolocators.Length(); i++) {
    if (mGeolocators[i]->HighAccuracyRequested()) {
      return true;
    }
  }

  return false;
}

void nsGeolocationService::UpdateAccuracy(bool aForceHigh) {
  bool highRequired = aForceHigh || HighAccuracyRequested();

  if (XRE_IsContentProcess()) {
    ContentChild* cpc = ContentChild::GetSingleton();
    if (cpc->IsAlive()) {
      cpc->SendSetGeolocationHigherAccuracy(highRequired);
    }

    return;
  }

  mProvider->SetHighAccuracy(!mHigherAccuracy && highRequired);
  mHigherAccuracy = highRequired;
}

void nsGeolocationService::StopDevice() {
  if (mDisconnectTimer) {
    mDisconnectTimer->Cancel();
    mDisconnectTimer = nullptr;
  }

  if (XRE_IsContentProcess()) {
    ContentChild* cpc = ContentChild::GetSingleton();
    cpc->SendRemoveGeolocationListener();

    return;  // bail early
  }

  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  if (!obs) {
    return;
  }

  if (!mProvider) {
    return;
  }

  mHigherAccuracy = false;

  mProvider->Shutdown();
  obs->NotifyObservers(mProvider, "geolocation-device-events", u"shutdown");
}

StaticRefPtr<nsGeolocationService> nsGeolocationService::sService;

already_AddRefed<nsGeolocationService>
nsGeolocationService::GetGeolocationService() {
  RefPtr<nsGeolocationService> result;
  if (nsGeolocationService::sService) {
    result = nsGeolocationService::sService;

    return result.forget();
  }

  result = new nsGeolocationService();
  if (NS_FAILED(result->Init())) {
    return nullptr;
  }

  ClearOnShutdown(&nsGeolocationService::sService);
  nsGeolocationService::sService = result;
  return result.forget();
}

void nsGeolocationService::AddLocator(Geolocation* aLocator) {
  mGeolocators.AppendElement(aLocator);
}

void nsGeolocationService::RemoveLocator(Geolocation* aLocator) {
  mGeolocators.RemoveElement(aLocator);
}

////////////////////////////////////////////////////
// Geolocation
////////////////////////////////////////////////////

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Geolocation)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY(nsISupports)
  NS_INTERFACE_MAP_ENTRY(nsIGeolocationUpdate)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(Geolocation)
NS_IMPL_CYCLE_COLLECTING_RELEASE(Geolocation)

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Geolocation, mPendingCallbacks,
                                      mWatchingCallbacks, mPendingRequests)

Geolocation::Geolocation()
    : mProtocolType(ProtocolType::OTHER), mLastWatchId(1) {}

Geolocation::~Geolocation() {
  if (mService) {
    Shutdown();
  }
}

StaticRefPtr<Geolocation> Geolocation::sNonWindowSingleton;

already_AddRefed<Geolocation> Geolocation::NonWindowSingleton() {
  if (sNonWindowSingleton) {
    return do_AddRef(sNonWindowSingleton);
  }

  RefPtr<Geolocation> result = new Geolocation();
  DebugOnly<nsresult> rv = result->Init();
  MOZ_ASSERT(NS_SUCCEEDED(rv), "How can this fail?");

  ClearOnShutdown(&sNonWindowSingleton);
  sNonWindowSingleton = result;
  return result.forget();
}

nsresult Geolocation::Init(nsPIDOMWindowInner* aContentDom) {
  // Remember the window
  if (aContentDom) {
    mOwner = do_GetWeakReference(aContentDom);
    if (!mOwner) {
      return NS_ERROR_FAILURE;
    }

    // Grab the principal of the document
    nsCOMPtr<Document> doc = aContentDom->GetDoc();
    if (!doc) {
      return NS_ERROR_FAILURE;
    }

    mPrincipal = doc->NodePrincipal();
    // Store the protocol to send via telemetry later.
    if (mPrincipal->SchemeIs("http")) {
      mProtocolType = ProtocolType::HTTP;
    } else if (mPrincipal->SchemeIs("https")) {
      mProtocolType = ProtocolType::HTTPS;
    }
  }

  // If no aContentDom was passed into us, we are being used
  // by chrome/c++ and have no mOwner, no mPrincipal, and no need
  // to prompt.
  mService = nsGeolocationService::GetGeolocationService();
  if (mService) {
    mService->AddLocator(this);
  }

  return NS_OK;
}

void Geolocation::Shutdown() {
  // Release all callbacks
  mPendingCallbacks.Clear();
  mWatchingCallbacks.Clear();

  if (mService) {
    mService->RemoveLocator(this);
    mService->UpdateAccuracy();
  }

  mService = nullptr;
  mPrincipal = nullptr;
}

nsPIDOMWindowInner* Geolocation::GetParentObject() const {
  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(mOwner);
  return window.get();
}

bool Geolocation::HasActiveCallbacks() {
  return mPendingCallbacks.Length() || mWatchingCallbacks.Length();
}

bool Geolocation::HighAccuracyRequested() {
  for (uint32_t i = 0; i < mWatchingCallbacks.Length(); i++) {
    if (mWatchingCallbacks[i]->WantsHighAccuracy()) {
      return true;
    }
  }

  for (uint32_t i = 0; i < mPendingCallbacks.Length(); i++) {
    if (mPendingCallbacks[i]->WantsHighAccuracy()) {
      return true;
    }
  }

  return false;
}

void Geolocation::RemoveRequest(nsGeolocationRequest* aRequest) {
  bool requestWasKnown = (mPendingCallbacks.RemoveElement(aRequest) !=
                          mWatchingCallbacks.RemoveElement(aRequest));

  Unused << requestWasKnown;
}

NS_IMETHODIMP
Geolocation::Update(nsIDOMGeoPosition* aSomewhere) {
  if (!WindowOwnerStillExists()) {
    Shutdown();
    return NS_OK;
  }

  // Don't update position if window is not fully active or the document is
  // hidden. We keep the pending callaback and watchers waiting for the next
  // update.
  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(this->GetOwner());
  if (window) {
    nsCOMPtr<Document> document = window->GetDoc();
    bool isHidden = document && document->Hidden();
    if (isHidden || !window->IsFullyActive()) {
      return NS_OK;
    }
  }

  if (aSomewhere) {
    nsCOMPtr<nsIDOMGeoPositionCoords> coords;
    aSomewhere->GetCoords(getter_AddRefs(coords));
    if (coords) {
      double accuracy = -1;
      coords->GetAccuracy(&accuracy);
      glean::geolocation::accuracy.AccumulateSingleSample(
          static_cast<uint64_t>(accuracy));
    }
  }

  for (uint32_t i = mPendingCallbacks.Length(); i > 0; i--) {
    mPendingCallbacks[i - 1]->Update(aSomewhere);
    RemoveRequest(mPendingCallbacks[i - 1]);
  }

  // notify everyone that is watching
  for (uint32_t i = 0; i < mWatchingCallbacks.Length(); i++) {
    mWatchingCallbacks[i]->Update(aSomewhere);
  }

  return NS_OK;
}

NS_IMETHODIMP
Geolocation::NotifyError(uint16_t aErrorCode) {
  MOZ_LOG(gGeolocationLog, LogLevel::Debug,
          ("Geolocation::NotifyError with error code: %u", aErrorCode));
  if (!WindowOwnerStillExists()) {
    Shutdown();
    return NS_OK;
  }

  for (uint32_t i = mPendingCallbacks.Length(); i > 0; i--) {
    RefPtr<nsGeolocationRequest> request = mPendingCallbacks[i - 1];
    request->NotifyErrorAndShutdown(aErrorCode);
    // NotifyErrorAndShutdown() removes the request from the array
  }

  // notify everyone that is watching
  for (uint32_t i = 0; i < mWatchingCallbacks.Length(); i++) {
    RefPtr<nsGeolocationRequest> request = mWatchingCallbacks[i];
    request->NotifyErrorAndShutdown(aErrorCode);
  }

  return NS_OK;
}

bool Geolocation::IsFullyActiveOrChrome() {
  // For regular content window, only allow this proceed if the window is "fully
  // active".
  if (nsPIDOMWindowInner* window = this->GetParentObject()) {
    return window->IsFullyActive();
  }
  // Calls coming from chrome code don't have window, so we can proceed.
  return true;
}

bool Geolocation::IsAlreadyCleared(nsGeolocationRequest* aRequest) {
  for (uint32_t i = 0, length = mClearedWatchIDs.Length(); i < length; ++i) {
    if (mClearedWatchIDs[i] == aRequest->WatchId()) {
      return true;
    }
  }

  return false;
}

bool Geolocation::ShouldBlockInsecureRequests() const {
  if (Preferences::GetBool(PREF_GEO_SECURITY_ALLOWINSECURE, false)) {
    return false;
  }

  nsCOMPtr<nsPIDOMWindowInner> win = do_QueryReferent(mOwner);
  if (!win) {
    return false;
  }

  nsCOMPtr<Document> doc = win->GetDoc();
  if (!doc) {
    return false;
  }

  if (!nsGlobalWindowInner::Cast(win)->IsSecureContext()) {
    nsContentUtils::ReportToConsole(nsIScriptError::errorFlag, "DOM"_ns, doc,
                                    nsContentUtils::eDOM_PROPERTIES,
                                    "GeolocationInsecureRequestIsForbidden");
    return true;
  }

  return false;
}

bool Geolocation::ClearPendingRequest(nsGeolocationRequest* aRequest) {
  if (aRequest->IsWatch() && this->IsAlreadyCleared(aRequest)) {
    this->NotifyAllowedRequest(aRequest);
    this->ClearWatch(aRequest->WatchId());
    return true;
  }

  return false;
}

void Geolocation::GetCurrentPosition(PositionCallback& aCallback,
                                     PositionErrorCallback* aErrorCallback,
                                     const PositionOptions& aOptions,
                                     CallerType aCallerType, ErrorResult& aRv) {
  nsresult rv = GetCurrentPosition(
      GeoPositionCallback(&aCallback), GeoPositionErrorCallback(aErrorCallback),
      CreatePositionOptionsCopy(aOptions), aCallerType);

  if (NS_FAILED(rv)) {
    aRv.Throw(rv);
  }
}

nsresult Geolocation::GetCurrentPosition(GeoPositionCallback callback,
                                         GeoPositionErrorCallback errorCallback,
                                         UniquePtr<PositionOptions>&& options,
                                         CallerType aCallerType) {
  if (!IsFullyActiveOrChrome()) {
    RefPtr<GeolocationPositionError> positionError =
        new GeolocationPositionError(
            this, GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
    positionError->NotifyCallback(errorCallback);
    return NS_OK;
  }

  if (mPendingCallbacks.Length() > MAX_GEO_REQUESTS_PER_WINDOW) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  // After this we hand over ownership of options to our nsGeolocationRequest.

  nsIEventTarget* target = GetMainThreadSerialEventTarget();
  RefPtr<nsGeolocationRequest> request = new nsGeolocationRequest(
      this, std::move(callback), std::move(errorCallback), std::move(options),
      target);

  if (!StaticPrefs::geo_enabled() || ShouldBlockInsecureRequests() ||
      !request->CheckPermissionDelegate()) {
    request->RequestDelayedTask(target,
                                nsGeolocationRequest::DelayedTaskType::Deny);
    return NS_OK;
  }

  if (!mOwner && aCallerType != CallerType::System) {
    return NS_ERROR_FAILURE;
  }

  if (mOwner) {
    RequestIfPermitted(request);
    return NS_OK;
  }

  if (aCallerType != CallerType::System) {
    return NS_ERROR_FAILURE;
  }

  request->RequestDelayedTask(target,
                              nsGeolocationRequest::DelayedTaskType::Allow);

  return NS_OK;
}

int32_t Geolocation::WatchPosition(PositionCallback& aCallback,
                                   PositionErrorCallback* aErrorCallback,
                                   const PositionOptions& aOptions,
                                   CallerType aCallerType, ErrorResult& aRv) {
  return WatchPosition(GeoPositionCallback(&aCallback),
                       GeoPositionErrorCallback(aErrorCallback),
                       CreatePositionOptionsCopy(aOptions), aCallerType, aRv);
}

int32_t Geolocation::WatchPosition(
    nsIDOMGeoPositionCallback* aCallback,
    nsIDOMGeoPositionErrorCallback* aErrorCallback,
    UniquePtr<PositionOptions>&& aOptions) {
  MOZ_ASSERT(aCallback);

  return WatchPosition(GeoPositionCallback(aCallback),
                       GeoPositionErrorCallback(aErrorCallback),
                       std::move(aOptions), CallerType::System, IgnoreErrors());
}

// On errors we return 0 because that's not a valid watch id and will
// get ignored in clearWatch.
int32_t Geolocation::WatchPosition(GeoPositionCallback aCallback,
                                   GeoPositionErrorCallback aErrorCallback,
                                   UniquePtr<PositionOptions>&& aOptions,
                                   CallerType aCallerType, ErrorResult& aRv) {
  if (!IsFullyActiveOrChrome()) {
    RefPtr<GeolocationPositionError> positionError =
        new GeolocationPositionError(
            this, GeolocationPositionError_Binding::POSITION_UNAVAILABLE);
    positionError->NotifyCallback(aErrorCallback);
    return 0;
  }

  if (mWatchingCallbacks.Length() > MAX_GEO_REQUESTS_PER_WINDOW) {
    aRv.Throw(NS_ERROR_NOT_AVAILABLE);
    return 0;
  }

  // The watch ID:
  int32_t watchId = mLastWatchId++;

  nsIEventTarget* target = GetMainThreadSerialEventTarget();
  RefPtr<nsGeolocationRequest> request = new nsGeolocationRequest(
      this, std::move(aCallback), std::move(aErrorCallback),
      std::move(aOptions), target, true, watchId);

  if (!StaticPrefs::geo_enabled() || ShouldBlockInsecureRequests() ||
      !request->CheckPermissionDelegate()) {
    request->RequestDelayedTask(target,
                                nsGeolocationRequest::DelayedTaskType::Deny);
    return watchId;
  }

  if (!mOwner && aCallerType != CallerType::System) {
    aRv.Throw(NS_ERROR_FAILURE);
    return 0;
  }

  if (mOwner) {
    RequestIfPermitted(request);
    return watchId;
  }

  if (aCallerType != CallerType::System) {
    aRv.Throw(NS_ERROR_FAILURE);
    return 0;
  }

  request->Allow(JS::UndefinedHandleValue);
  return watchId;
}

void Geolocation::ClearWatch(int32_t aWatchId) {
  if (aWatchId < 1) {
    return;
  }

  if (!mClearedWatchIDs.Contains(aWatchId)) {
    mClearedWatchIDs.AppendElement(aWatchId);
  }

  for (uint32_t i = 0, length = mWatchingCallbacks.Length(); i < length; ++i) {
    if (mWatchingCallbacks[i]->WatchId() == aWatchId) {
      mWatchingCallbacks[i]->Shutdown();
      RemoveRequest(mWatchingCallbacks[i]);
      mClearedWatchIDs.RemoveElement(aWatchId);
      break;
    }
  }

  // make sure we also search through the pending requests lists for
  // watches to clear...
  for (uint32_t i = 0, length = mPendingRequests.Length(); i < length; ++i) {
    if (mPendingRequests[i]->IsWatch() &&
        (mPendingRequests[i]->WatchId() == aWatchId)) {
      mPendingRequests[i]->Shutdown();
      mPendingRequests.RemoveElementAt(i);
      break;
    }
  }
}

bool Geolocation::WindowOwnerStillExists() {
  // an owner was never set when Geolocation
  // was created, which means that this object
  // is being used without a window.
  if (mOwner == nullptr) {
    return true;
  }

  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(mOwner);

  if (window) {
    nsPIDOMWindowOuter* outer = window->GetOuterWindow();
    if (!outer || outer->GetCurrentInnerWindow() != window || outer->Closed()) {
      return false;
    }
  }

  return true;
}

void Geolocation::NotifyAllowedRequest(nsGeolocationRequest* aRequest) {
  if (aRequest->IsWatch()) {
    mWatchingCallbacks.AppendElement(aRequest);
  } else {
    mPendingCallbacks.AppendElement(aRequest);
  }
}

/* static */ bool Geolocation::RegisterRequestWithPrompt(
    nsGeolocationRequest* request) {
  nsIEventTarget* target = GetMainThreadSerialEventTarget();
  ContentPermissionRequestBase::PromptResult pr = request->CheckPromptPrefs();
  if (pr == ContentPermissionRequestBase::PromptResult::Granted) {
    request->RequestDelayedTask(target,
                                nsGeolocationRequest::DelayedTaskType::Allow);
    return true;
  }
  if (pr == ContentPermissionRequestBase::PromptResult::Denied) {
    request->RequestDelayedTask(target,
                                nsGeolocationRequest::DelayedTaskType::Deny);
    return true;
  }

  request->RequestDelayedTask(target,
                              nsGeolocationRequest::DelayedTaskType::Request);
  return true;
}

/* static */ geolocation::SystemGeolocationPermissionBehavior
Geolocation::GetLocationOSPermission() {
  auto permission = geolocation::GetGeolocationPermissionBehavior();

  if (!StaticPrefs::geo_prompt_open_system_prefs() &&
      permission == geolocation::SystemGeolocationPermissionBehavior::
                        GeckoWillPromptUser) {
    return geolocation::SystemGeolocationPermissionBehavior::NoPrompt;
  }
  return permission;
}

void Geolocation::RequestIfPermitted(nsGeolocationRequest* request) {
  auto getPermission = [request = RefPtr{request}](auto aPermission) {
    switch (aPermission) {
      case geolocation::SystemGeolocationPermissionBehavior::
          SystemWillPromptUser:
      case geolocation::SystemGeolocationPermissionBehavior::
          GeckoWillPromptUser:
        request->SetPromptBehavior(aPermission);
        break;
      case geolocation::SystemGeolocationPermissionBehavior::NoPrompt:
        // Either location access is already permitted by OS or the system
        // permission UX is not available for this platform.  Do nothing.
        break;
      default:
        MOZ_ASSERT_UNREACHABLE(
            "unexpected GeolocationPermissionBehavior value");
        break;
    }
    RegisterRequestWithPrompt(request);
  };

  if (auto* contentChild = ContentChild::GetSingleton()) {
    contentChild->SendGetSystemGeolocationPermissionBehavior(
        std::move(getPermission),
        [request =
             RefPtr{request}](mozilla::ipc::ResponseRejectReason aReason) {
          NS_WARNING("Error sending GetSystemGeolocationPermissionBehavior");
          // We still need to run the location request, even if we don't
          // have permission.
          RegisterRequestWithPrompt(request);
        });
  } else {
    MOZ_ASSERT(XRE_IsParentProcess());
    getPermission(GetLocationOSPermission());
  }
}

JSObject* Geolocation::WrapObject(JSContext* aCtx,
                                  JS::Handle<JSObject*> aGivenProto) {
  return Geolocation_Binding::Wrap(aCtx, this, aGivenProto);
}

quality94%

¤ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.