From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- dom/system/windows/location/PWindowsLocation.ipdl | 38 +++ .../windows/location/WindowsLocationChild.cpp | 257 +++++++++++++++ dom/system/windows/location/WindowsLocationChild.h | 44 +++ .../windows/location/WindowsLocationParent.cpp | 36 +++ .../windows/location/WindowsLocationParent.h | 52 +++ .../windows/location/WindowsLocationProvider.cpp | 350 +++++++++++++++++++++ .../windows/location/WindowsLocationProvider.h | 78 +++++ dom/system/windows/location/moz.build | 29 ++ 8 files changed, 884 insertions(+) create mode 100644 dom/system/windows/location/PWindowsLocation.ipdl create mode 100644 dom/system/windows/location/WindowsLocationChild.cpp create mode 100644 dom/system/windows/location/WindowsLocationChild.h create mode 100644 dom/system/windows/location/WindowsLocationParent.cpp create mode 100644 dom/system/windows/location/WindowsLocationParent.h create mode 100644 dom/system/windows/location/WindowsLocationProvider.cpp create mode 100644 dom/system/windows/location/WindowsLocationProvider.h create mode 100644 dom/system/windows/location/moz.build (limited to 'dom/system/windows/location') diff --git a/dom/system/windows/location/PWindowsLocation.ipdl b/dom/system/windows/location/PWindowsLocation.ipdl new file mode 100644 index 0000000000..db53b5c805 --- /dev/null +++ b/dom/system/windows/location/PWindowsLocation.ipdl @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et ft=cpp : */ +/* 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 protocol PWindowsUtils; + +[RefCounted] using class nsIDOMGeoPosition from "nsGeoPositionIPCSerialiser.h"; + +namespace mozilla { +namespace dom { + +// Proxies geolocation functions to a utility process so that we +// can safely handle crashes in the ILocation API. Messages to the child +// are proxies for the ILocation COM object. Messages to the parent +// are proxied nsIGeolocationUpdate callbacks. +protocol PWindowsLocation { + manager PWindowsUtils; + +child: + async Startup(); + async RegisterForReport(); + async UnregisterForReport(); + async SetHighAccuracy(bool aEnable); + + async __delete__(); + +parent: + // Update geolocation with new position information. + async Update(nullable nsIDOMGeoPosition aPosition); + + // The geolocation API has reported an error. + async Failed(uint16_t aError); +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/system/windows/location/WindowsLocationChild.cpp b/dom/system/windows/location/WindowsLocationChild.cpp new file mode 100644 index 0000000000..514ae4610f --- /dev/null +++ b/dom/system/windows/location/WindowsLocationChild.cpp @@ -0,0 +1,257 @@ +/* -*- 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 "WindowsLocationChild.h" +#include "nsCOMPtr.h" +#include "WindowsLocationProvider.h" +#include "mozilla/dom/GeolocationPosition.h" +#include "mozilla/dom/GeolocationPositionErrorBinding.h" +#include "mozilla/Telemetry.h" +#include "nsIGeolocationProvider.h" + +#include + +namespace mozilla::dom { + +extern LazyLogModule gWindowsLocationProviderLog; +#define LOG(...) \ + MOZ_LOG(gWindowsLocationProviderLog, LogLevel::Debug, (__VA_ARGS__)) + +class LocationEvent final : public ILocationEvents { + public: + explicit LocationEvent(WindowsLocationChild* aActor) + : mActor(aActor), mRefCnt(0) {} + + // IUnknown interface + STDMETHODIMP_(ULONG) AddRef() override; + STDMETHODIMP_(ULONG) Release() override; + STDMETHODIMP QueryInterface(REFIID iid, void** ppv) override; + + // ILocationEvents interface + STDMETHODIMP OnStatusChanged(REFIID aReportType, + LOCATION_REPORT_STATUS aStatus) override; + STDMETHODIMP OnLocationChanged(REFIID aReportType, + ILocationReport* aReport) override; + + private: + // Making this a WeakPtr breaks the following cycle of strong references: + // WindowsLocationChild -> ILocation -> ILocationEvents (this) + // -> WindowsLocationChild. + WeakPtr mActor; + + ULONG mRefCnt; +}; + +STDMETHODIMP_(ULONG) +LocationEvent::AddRef() { return InterlockedIncrement(&mRefCnt); } + +STDMETHODIMP_(ULONG) +LocationEvent::Release() { + ULONG count = InterlockedDecrement(&mRefCnt); + if (!count) { + delete this; + return 0; + } + return count; +} + +STDMETHODIMP +LocationEvent::QueryInterface(REFIID iid, void** ppv) { + if (!ppv) { + return E_INVALIDARG; + } + + if (iid == IID_IUnknown) { + *ppv = static_cast(this); + } else if (iid == IID_ILocationEvents) { + *ppv = static_cast(this); + } else { + *ppv = nullptr; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; +} + +STDMETHODIMP +LocationEvent::OnStatusChanged(REFIID aReportType, + LOCATION_REPORT_STATUS aStatus) { + LOG("LocationEvent::OnStatusChanged(%p, %p, %s, %04x)", this, mActor.get(), + aReportType == IID_ILatLongReport ? "true" : "false", + static_cast(aStatus)); + + if (!mActor || aReportType != IID_ILatLongReport) { + return S_OK; + } + + // When registering event, REPORT_INITIALIZING is fired at first. + // Then, when the location is found, REPORT_RUNNING is fired. + // We ignore those messages. + uint16_t err; + switch (aStatus) { + case REPORT_ACCESS_DENIED: + err = GeolocationPositionError_Binding::PERMISSION_DENIED; + break; + case REPORT_NOT_SUPPORTED: + case REPORT_ERROR: + err = GeolocationPositionError_Binding::POSITION_UNAVAILABLE; + break; + default: + return S_OK; + } + + mActor->SendFailed(err); + return S_OK; +} + +STDMETHODIMP +LocationEvent::OnLocationChanged(REFIID aReportType, ILocationReport* aReport) { + LOG("LocationEvent::OnLocationChanged(%p, %p, %s)", this, mActor.get(), + aReportType == IID_ILatLongReport ? "true" : "false"); + + if (!mActor || aReportType != IID_ILatLongReport) { + return S_OK; + } + + RefPtr latLongReport; + if (FAILED(aReport->QueryInterface(IID_ILatLongReport, + getter_AddRefs(latLongReport)))) { + return E_FAIL; + } + + DOUBLE latitude = 0.0; + latLongReport->GetLatitude(&latitude); + + DOUBLE longitude = 0.0; + latLongReport->GetLongitude(&longitude); + + DOUBLE alt = UnspecifiedNaN(); + latLongReport->GetAltitude(&alt); + + DOUBLE herror = 0.0; + latLongReport->GetErrorRadius(&herror); + + DOUBLE verror = UnspecifiedNaN(); + latLongReport->GetAltitudeError(&verror); + + double heading = UnspecifiedNaN(); + double speed = UnspecifiedNaN(); + + // nsGeoPositionCoords will convert NaNs to null for optional properties of + // the JavaScript Coordinates object. + RefPtr position = + new nsGeoPosition(latitude, longitude, alt, herror, verror, heading, + speed, PR_Now() / PR_USEC_PER_MSEC); + mActor->SendUpdate(position); + + return S_OK; +} + +WindowsLocationChild::WindowsLocationChild() { + LOG("WindowsLocationChild::WindowsLocationChild(%p)", this); +} + +WindowsLocationChild::~WindowsLocationChild() { + LOG("WindowsLocationChild::~WindowsLocationChild(%p)", this); +} + +::mozilla::ipc::IPCResult WindowsLocationChild::RecvStartup() { + LOG("WindowsLocationChild::RecvStartup(%p, %p)", this, mLocation.get()); + if (mLocation) { + return IPC_OK(); + } + + RefPtr location; + if (FAILED(::CoCreateInstance(CLSID_Location, nullptr, CLSCTX_INPROC_SERVER, + IID_ILocation, getter_AddRefs(location)))) { + LOG("WindowsLocationChild(%p) failed to create ILocation", this); + // We will use MLS provider + SendFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + return IPC_OK(); + } + + IID reportTypes[] = {IID_ILatLongReport}; + if (FAILED(location->RequestPermissions(nullptr, reportTypes, 1, FALSE))) { + LOG("WindowsLocationChild(%p) failed to set ILocation permissions", this); + // We will use MLS provider + SendFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + return IPC_OK(); + } + + mLocation = location; + return IPC_OK(); +} + +::mozilla::ipc::IPCResult WindowsLocationChild::RecvSetHighAccuracy( + bool aEnable) { + LOG("WindowsLocationChild::RecvSetHighAccuracy(%p, %p, %s)", this, + mLocation.get(), aEnable ? "true" : "false"); + + // We sometimes call SetHighAccuracy before Startup, so we save the + // request and set it later, in RegisterForReport. + mHighAccuracy = aEnable; + + return IPC_OK(); +} + +::mozilla::ipc::IPCResult WindowsLocationChild::RecvRegisterForReport() { + LOG("WindowsLocationChild::RecvRegisterForReport(%p, %p)", this, + mLocation.get()); + + if (!mLocation) { + SendFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + return IPC_OK(); + } + + LOCATION_DESIRED_ACCURACY desiredAccuracy; + if (mHighAccuracy) { + desiredAccuracy = LOCATION_DESIRED_ACCURACY_HIGH; + } else { + desiredAccuracy = LOCATION_DESIRED_ACCURACY_DEFAULT; + } + + if (NS_WARN_IF(FAILED(mLocation->SetDesiredAccuracy(IID_ILatLongReport, + desiredAccuracy)))) { + SendFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + return IPC_OK(); + } + + auto event = MakeRefPtr(this); + if (NS_WARN_IF( + FAILED(mLocation->RegisterForReport(event, IID_ILatLongReport, 0)))) { + SendFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + } + + LOG("WindowsLocationChild::RecvRegisterForReport successfully registered"); + return IPC_OK(); +} + +::mozilla::ipc::IPCResult WindowsLocationChild::RecvUnregisterForReport() { + LOG("WindowsLocationChild::RecvUnregisterForReport(%p, %p)", this, + mLocation.get()); + + if (!mLocation) { + return IPC_OK(); + } + + // This will free the LocationEvent we created in RecvRegisterForReport. + Unused << NS_WARN_IF( + FAILED(mLocation->UnregisterForReport(IID_ILatLongReport))); + + // The ILocation object is not reusable. Unregistering, restarting and + // re-registering for reports does not work; the callback is never + // called in that case. For that reason, we re-create the ILocation + // object with a call to Startup after unregistering if we need it again. + mLocation = nullptr; + return IPC_OK(); +} + +void WindowsLocationChild::ActorDestroy(ActorDestroyReason aWhy) { + LOG("WindowsLocationChild::ActorDestroy(%p, %p)", this, mLocation.get()); + mLocation = nullptr; +} + +} // namespace mozilla::dom diff --git a/dom/system/windows/location/WindowsLocationChild.h b/dom/system/windows/location/WindowsLocationChild.h new file mode 100644 index 0000000000..ac51cff213 --- /dev/null +++ b/dom/system/windows/location/WindowsLocationChild.h @@ -0,0 +1,44 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_WindowsLocationChild_h__ +#define mozilla_dom_WindowsLocationChild_h__ + +#include "mozilla/dom/PWindowsLocationChild.h" +#include "mozilla/WeakPtr.h" + +class ILocation; + +namespace mozilla::dom { + +// Geolocation actor in utility process. +class WindowsLocationChild final : public PWindowsLocationChild, + public SupportsWeakPtr { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WindowsLocationChild, override); + + public: + WindowsLocationChild(); + + using IPCResult = ::mozilla::ipc::IPCResult; + + IPCResult RecvStartup(); + IPCResult RecvRegisterForReport(); + IPCResult RecvUnregisterForReport(); + IPCResult RecvSetHighAccuracy(bool aEnable); + void ActorDestroy(ActorDestroyReason aWhy) override; + + private: + ~WindowsLocationChild() override; + + // The COM object the actors are proxying calls for. + RefPtr mLocation; + + bool mHighAccuracy = false; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_WindowsLocationChild_h__ diff --git a/dom/system/windows/location/WindowsLocationParent.cpp b/dom/system/windows/location/WindowsLocationParent.cpp new file mode 100644 index 0000000000..f19bcb8b0d --- /dev/null +++ b/dom/system/windows/location/WindowsLocationParent.cpp @@ -0,0 +1,36 @@ +/* -*- 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 "WindowsLocationParent.h" +#include "nsIDOMGeoPosition.h" +#include "WindowsLocationProvider.h" + +namespace mozilla::dom { + +::mozilla::ipc::IPCResult WindowsLocationParent::RecvUpdate( + RefPtr aGeoPosition) { + if (mProvider) { + mProvider->RecvUpdate(aGeoPosition); + } + return IPC_OK(); +} + +// A failure occurred. This may be translated into a +// nsIGeolocationUpdate::NotifyError or may be ignored if the MLS fallback +// is available. +::mozilla::ipc::IPCResult WindowsLocationParent::RecvFailed(uint16_t err) { + if (mProvider) { + mProvider->RecvFailed(err); + } + return IPC_OK(); +} + +void WindowsLocationParent::ActorDestroy(ActorDestroyReason aReason) { + if (mProvider) { + mProvider->ActorStopped(); + } +} + +} // namespace mozilla::dom diff --git a/dom/system/windows/location/WindowsLocationParent.h b/dom/system/windows/location/WindowsLocationParent.h new file mode 100644 index 0000000000..01538246ea --- /dev/null +++ b/dom/system/windows/location/WindowsLocationParent.h @@ -0,0 +1,52 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_WindowsLocationParent_h__ +#define mozilla_dom_WindowsLocationParent_h__ + +#include "nsCOMPtr.h" +#include "mozilla/dom/PWindowsLocationParent.h" + +class nsGeoPosition; +class nsIGeolocationUpdate; + +namespace mozilla::dom { + +class WindowsLocationProvider; + +// Geolocation actor in main process. +// This may receive messages asynchronously, even after it sends Unregister +// to the child. +class WindowsLocationParent final : public PWindowsLocationParent { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WindowsLocationParent, override); + + using IPCResult = ::mozilla::ipc::IPCResult; + + explicit WindowsLocationParent(WindowsLocationProvider* aProvider) + : mProvider(aProvider) {} + + // Update geolocation with new position information. + IPCResult RecvUpdate(RefPtr aGeoPosition); + + // A failure occurred. This may be translated into a + // nsIGeolocationUpdate::NotifyError or may be ignored if the MLS fallback + // is available. + IPCResult RecvFailed(uint16_t err); + + void ActorDestroy(ActorDestroyReason aReason) override; + + // After this, the actor will simply ignore any incoming messages. + void DetachFromLocationProvider() { mProvider = nullptr; } + + private: + ~WindowsLocationParent() override = default; + + WindowsLocationProvider* mProvider; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_WindowsLocationParent_h__ diff --git a/dom/system/windows/location/WindowsLocationProvider.cpp b/dom/system/windows/location/WindowsLocationProvider.cpp new file mode 100644 index 0000000000..92a6f2c9cc --- /dev/null +++ b/dom/system/windows/location/WindowsLocationProvider.cpp @@ -0,0 +1,350 @@ +/* -*- 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 "WindowsLocationProvider.h" +#include "WindowsLocationParent.h" +#include "mozilla/dom/WindowsUtilsParent.h" +#include "GeolocationPosition.h" +#include "nsComponentManagerUtils.h" +#include "mozilla/ipc/UtilityProcessManager.h" +#include "mozilla/ipc/UtilityProcessSandboxing.h" +#include "prtime.h" +#include "MLSFallback.h" +#include "mozilla/Attributes.h" +#include "mozilla/Logging.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/Telemetry.h" +#include "mozilla/dom/GeolocationPositionErrorBinding.h" + +namespace mozilla::dom { + +LazyLogModule gWindowsLocationProviderLog("WindowsLocationProvider"); +#define LOG(...) \ + MOZ_LOG(gWindowsLocationProviderLog, LogLevel::Debug, (__VA_ARGS__)) + +class MLSUpdate : public nsIGeolocationUpdate { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGEOLOCATIONUPDATE + explicit MLSUpdate(nsIGeolocationUpdate* aCallback) : mCallback(aCallback) {} + + private: + nsCOMPtr mCallback; + virtual ~MLSUpdate() {} +}; + +NS_IMPL_ISUPPORTS(MLSUpdate, nsIGeolocationUpdate); + +NS_IMETHODIMP +MLSUpdate::Update(nsIDOMGeoPosition* aPosition) { + if (!mCallback) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr coords; + aPosition->GetCoords(getter_AddRefs(coords)); + if (!coords) { + return NS_ERROR_FAILURE; + } + Telemetry::Accumulate(Telemetry::GEOLOCATION_WIN8_SOURCE_IS_MLS, true); + return mCallback->Update(aPosition); +} +NS_IMETHODIMP +MLSUpdate::NotifyError(uint16_t aError) { + if (!mCallback) { + return NS_ERROR_FAILURE; + } + nsCOMPtr callback(mCallback); + return callback->NotifyError(aError); +} + +NS_IMPL_ISUPPORTS(WindowsLocationProvider, nsIGeolocationProvider) + +WindowsLocationProvider::WindowsLocationProvider() { + LOG("WindowsLocationProvider::WindowsLocationProvider(%p)", this); + MOZ_ASSERT(XRE_IsParentProcess()); + MaybeCreateLocationActor(); +} + +WindowsLocationProvider::~WindowsLocationProvider() { + LOG("WindowsLocationProvider::~WindowsLocationProvider(%p,%p,%p)", this, + mActor.get(), mActorPromise.get()); + Send__delete__(); + ReleaseUtilityProcess(); + CancelMLSProvider(); +} + +void WindowsLocationProvider::MaybeCreateLocationActor() { + LOG("WindowsLocationProvider::MaybeCreateLocationActor(%p)", this); + if (mActor || mActorPromise) { + return; + } + + auto utilityProc = mozilla::ipc::UtilityProcessManager::GetSingleton(); + MOZ_ASSERT(utilityProc); + + // Create a PWindowsLocation actor in the Windows utility process. + // This will attempt to launch the process if it doesn't already exist. + RefPtr self = this; + auto wuPromise = utilityProc->GetWindowsUtilsPromise(); + mActorPromise = wuPromise->Then( + GetCurrentSerialEventTarget(), __func__, + [self](RefPtr wup) { + self->mActorPromise = nullptr; + auto actor = MakeRefPtr(self); + if (!wup->SendPWindowsLocationConstructor(actor)) { + LOG("WindowsLocationProvider(%p) SendPWindowsLocationConstructor " + "failed", + self.get()); + actor->DetachFromLocationProvider(); + self->mActor = nullptr; + return WindowsLocationPromise::CreateAndReject(false, __func__); + } + LOG("WindowsLocationProvider connected to actor (%p,%p,%p)", self.get(), + self->mActor.get(), self->mActorPromise.get()); + self->mActor = actor; + return WindowsLocationPromise::CreateAndResolve(self->mActor, __func__); + }, + + [self](nsresult aError) { + LOG("WindowsLocationProvider failed to connect to actor (%p,%p,%p)", + self.get(), self->mActor.get(), self->mActorPromise.get()); + self->mActorPromise = nullptr; + return WindowsLocationPromise::CreateAndReject(false, __func__); + }); + + if (mActor) { + // Utility process already existed and mActorPromise was resolved + // immediately. + mActorPromise = nullptr; + } +} + +void WindowsLocationProvider::ReleaseUtilityProcess() { + LOG("WindowsLocationProvider::ReleaseUtilityProcess(%p)", this); + auto utilityProc = mozilla::ipc::UtilityProcessManager::GetIfExists(); + if (utilityProc) { + utilityProc->ReleaseWindowsUtils(); + } +} + +template +bool WindowsLocationProvider::WhenActorIsReady(Fn&& fn) { + if (mActor) { + return fn(mActor); + } + + if (mActorPromise) { + mActorPromise->Then( + GetCurrentSerialEventTarget(), __func__, + [fn](const RefPtr& actor) { + Unused << fn(actor.get()); + return actor; + }, + [](bool) { return false; }); + return true; + } + + // The remote process failed to start. + return false; +} + +bool WindowsLocationProvider::SendStartup() { + LOG("WindowsLocationProvider::SendStartup(%p)", this); + MaybeCreateLocationActor(); + return WhenActorIsReady( + [](WindowsLocationParent* actor) { return actor->SendStartup(); }); +} + +bool WindowsLocationProvider::SendRegisterForReport( + nsIGeolocationUpdate* aCallback) { + LOG("WindowsLocationProvider::SendRegisterForReport(%p)", this); + RefPtr self = this; + RefPtr cb = aCallback; + return WhenActorIsReady([self, cb](WindowsLocationParent* actor) { + MOZ_ASSERT(!self->mCallback); + if (actor->SendRegisterForReport()) { + self->mCallback = cb; + return true; + } + return false; + }); +} + +bool WindowsLocationProvider::SendUnregisterForReport() { + LOG("WindowsLocationProvider::SendUnregisterForReport(%p)", this); + RefPtr self = this; + return WhenActorIsReady([self](WindowsLocationParent* actor) { + self->mCallback = nullptr; + if (actor->SendUnregisterForReport()) { + return true; + } + return false; + }); +} + +bool WindowsLocationProvider::SendSetHighAccuracy(bool aEnable) { + LOG("WindowsLocationProvider::SendSetHighAccuracy(%p)", this); + return WhenActorIsReady([aEnable](WindowsLocationParent* actor) { + return actor->SendSetHighAccuracy(aEnable); + }); +} + +bool WindowsLocationProvider::Send__delete__() { + LOG("WindowsLocationProvider::Send__delete__(%p)", this); + return WhenActorIsReady([self = RefPtr{this}](WindowsLocationParent*) { + if (WindowsLocationParent::Send__delete__(self->mActor)) { + if (self->mActor) { + self->mActor->DetachFromLocationProvider(); + self->mActor = nullptr; + } + return true; + } + return false; + }); +} + +void WindowsLocationProvider::RecvUpdate( + RefPtr aGeoPosition) { + LOG("WindowsLocationProvider::RecvUpdate(%p)", this); + if (!mCallback) { + return; + } + + mCallback->Update(aGeoPosition.get()); + + Telemetry::Accumulate(Telemetry::GEOLOCATION_WIN8_SOURCE_IS_MLS, false); +} + +void WindowsLocationProvider::RecvFailed(uint16_t err) { + LOG("WindowsLocationProvider::RecvFailed(%p)", this); + // Cannot get current location at this time. We use MLS instead. + if (mMLSProvider || !mCallback) { + return; + } + + if (NS_SUCCEEDED(CreateAndWatchMLSProvider(mCallback))) { + return; + } + + // No ILocation and no MLS, so we have failed completely. + // We keep strong references to objects that we need to guarantee + // will live past the NotifyError callback. + RefPtr self = this; + nsCOMPtr callback = mCallback; + callback->NotifyError(err); +} + +void WindowsLocationProvider::ActorStopped() { + // ActorDestroy has run. Make sure UtilityProcessHost no longer tries to use + // it. + ReleaseUtilityProcess(); + + if (mWatching) { + // Treat as remote geolocation error, which will cause it to fallback + // to MLS if it hasn't already. + mWatching = false; + RecvFailed(GeolocationPositionError_Binding::POSITION_UNAVAILABLE); + return; + } + + MOZ_ASSERT(!mActorPromise); + if (mActor) { + mActor->DetachFromLocationProvider(); + mActor = nullptr; + } +} + +NS_IMETHODIMP +WindowsLocationProvider::Startup() { + LOG("WindowsLocationProvider::Startup(%p, %p, %p)", this, mActor.get(), + mActorPromise.get()); + // If this fails, we will use the MLS fallback. + SendStartup(); + return NS_OK; +} + +NS_IMETHODIMP +WindowsLocationProvider::Watch(nsIGeolocationUpdate* aCallback) { + LOG("WindowsLocationProvider::Watch(%p, %p, %p, %p, %d)", this, mActor.get(), + mActorPromise.get(), aCallback, mWatching); + if (mWatching) { + return NS_OK; + } + + if (SendRegisterForReport(aCallback)) { + mWatching = true; + return NS_OK; + } + + // Couldn't send request. We will use MLS instead. + return CreateAndWatchMLSProvider(aCallback); +} + +NS_IMETHODIMP +WindowsLocationProvider::Shutdown() { + LOG("WindowsLocationProvider::Shutdown(%p, %p, %p)", this, mActor.get(), + mActorPromise.get()); + + if (mWatching) { + SendUnregisterForReport(); + mWatching = false; + } + + CancelMLSProvider(); + return NS_OK; +} + +NS_IMETHODIMP +WindowsLocationProvider::SetHighAccuracy(bool enable) { + LOG("WindowsLocationProvider::SetHighAccuracy(%p, %p, %p, %s)", this, + mActor.get(), mActorPromise.get(), enable ? "true" : "false"); + if (mMLSProvider) { + // Ignored when running MLS fallback. + return NS_OK; + } + + if (!SendSetHighAccuracy(enable)) { + return NS_ERROR_FAILURE; + } + + // Since we SendSetHighAccuracy asynchronously, we cannot say for sure + // that it will succeed. If it does fail then we will get a + // RecvFailed IPC message, which will cause a fallback to MLS. + return NS_OK; +} + +nsresult WindowsLocationProvider::CreateAndWatchMLSProvider( + nsIGeolocationUpdate* aCallback) { + LOG("WindowsLocationProvider::CreateAndWatchMLSProvider" + "(%p, %p, %p, %p, %p)", + this, mMLSProvider.get(), mActor.get(), mActorPromise.get(), aCallback); + + if (mMLSProvider) { + return NS_OK; + } + + mMLSProvider = new MLSFallback(0); + return mMLSProvider->Startup(new MLSUpdate(aCallback)); +} + +void WindowsLocationProvider::CancelMLSProvider() { + LOG("WindowsLocationProvider::CancelMLSProvider" + "(%p, %p, %p, %p, %p)", + this, mMLSProvider.get(), mActor.get(), mActorPromise.get(), + mCallback.get()); + + if (!mMLSProvider) { + return; + } + + mMLSProvider->Shutdown(); + mMLSProvider = nullptr; +} + +#undef LOG + +} // namespace mozilla::dom diff --git a/dom/system/windows/location/WindowsLocationProvider.h b/dom/system/windows/location/WindowsLocationProvider.h new file mode 100644 index 0000000000..d1e4dfa936 --- /dev/null +++ b/dom/system/windows/location/WindowsLocationProvider.h @@ -0,0 +1,78 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_WindowsLocationProvider_h__ +#define mozilla_dom_WindowsLocationProvider_h__ + +#include "nsCOMPtr.h" +#include "nsIGeolocationProvider.h" +#include "mozilla/MozPromise.h" + +class MLSFallback; + +namespace mozilla::dom { + +class WindowsLocationParent; + +// Uses a PWindowsLocation actor to subscribe to geolocation updates from the +// Windows utility process and falls back to MLS when it is not available or +// fails. +class WindowsLocationProvider final : public nsIGeolocationProvider { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGEOLOCATIONPROVIDER + + WindowsLocationProvider(); + + private: + friend WindowsLocationParent; + + ~WindowsLocationProvider(); + + nsresult CreateAndWatchMLSProvider(nsIGeolocationUpdate* aCallback); + void CancelMLSProvider(); + + void MaybeCreateLocationActor(); + void ReleaseUtilityProcess(); + + // These methods either send the message on the existing actor or queue + // the messages to be sent (in order) once the actor exists. + bool SendStartup(); + bool SendRegisterForReport(nsIGeolocationUpdate* aCallback); + bool SendUnregisterForReport(); + bool SendSetHighAccuracy(bool aEnable); + bool Send__delete__(); + + void RecvUpdate(RefPtr aGeoPosition); + // See bug 1539864 for MOZ_CAN_RUN_SCRIPT_BOUNDARY justification. + MOZ_CAN_RUN_SCRIPT_BOUNDARY void RecvFailed(uint16_t err); + + // The utility process actor has ended its connection, either successfully + // or with an error. + void ActorStopped(); + + // Run fn once actor is ready to send messages, which may be immediately. + template + bool WhenActorIsReady(Fn&& fn); + + RefPtr mMLSProvider; + + nsCOMPtr mCallback; + + using WindowsLocationPromise = + MozPromise, bool, false>; + + // Before the utility process exists, we have a promise that we will get our + // location actor. mActor and mActorPromise are never both set. + RefPtr mActorPromise; + RefPtr mActor; + + bool mWatching = false; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_WindowsLocationProvider_h__ diff --git a/dom/system/windows/location/moz.build b/dom/system/windows/location/moz.build new file mode 100644 index 0000000000..8fafb99fb1 --- /dev/null +++ b/dom/system/windows/location/moz.build @@ -0,0 +1,29 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXPORTS.mozilla.dom += [ + "WindowsLocationChild.h", + "WindowsLocationParent.h", +] + +UNIFIED_SOURCES += [ + "WindowsLocationParent.cpp", + "WindowsLocationProvider.cpp", +] + +SOURCES += [ + "WindowsLocationChild.cpp", # includes locationapi.h +] + +IPDL_SOURCES += [ + "PWindowsLocation.ipdl", +] + +LOCAL_INCLUDES += ["/dom/geolocation"] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" -- cgit v1.2.3