summaryrefslogtreecommitdiffstats
path: root/mobile/android/components/geckoview
diff options
context:
space:
mode:
Diffstat (limited to 'mobile/android/components/geckoview')
-rw-r--r--mobile/android/components/geckoview/ColorPickerDelegate.sys.mjs38
-rw-r--r--mobile/android/components/geckoview/FilePickerDelegate.sys.mjs189
-rw-r--r--mobile/android/components/geckoview/GeckoView.manifest4
-rw-r--r--mobile/android/components/geckoview/GeckoViewContentChannel.cpp47
-rw-r--r--mobile/android/components/geckoview/GeckoViewContentChannel.h23
-rw-r--r--mobile/android/components/geckoview/GeckoViewContentProtocolHandler.cpp54
-rw-r--r--mobile/android/components/geckoview/GeckoViewContentProtocolHandler.h27
-rw-r--r--mobile/android/components/geckoview/GeckoViewExternalAppService.cpp98
-rw-r--r--mobile/android/components/geckoview/GeckoViewExternalAppService.h26
-rw-r--r--mobile/android/components/geckoview/GeckoViewHistory.cpp508
-rw-r--r--mobile/android/components/geckoview/GeckoViewHistory.h60
-rw-r--r--mobile/android/components/geckoview/GeckoViewInputStream.cpp110
-rw-r--r--mobile/android/components/geckoview/GeckoViewInputStream.h43
-rw-r--r--mobile/android/components/geckoview/GeckoViewOutputStream.cpp61
-rw-r--r--mobile/android/components/geckoview/GeckoViewOutputStream.h29
-rw-r--r--mobile/android/components/geckoview/GeckoViewPermission.sys.mjs36
-rw-r--r--mobile/android/components/geckoview/GeckoViewPrompt.sys.mjs831
-rw-r--r--mobile/android/components/geckoview/GeckoViewPrompter.sys.mjs206
-rw-r--r--mobile/android/components/geckoview/GeckoViewPush.sys.mjs264
-rw-r--r--mobile/android/components/geckoview/GeckoViewStartup.sys.mjs364
-rw-r--r--mobile/android/components/geckoview/GeckoViewStreamListener.cpp298
-rw-r--r--mobile/android/components/geckoview/GeckoViewStreamListener.h57
-rw-r--r--mobile/android/components/geckoview/LoginStorageDelegate.sys.mjs126
-rw-r--r--mobile/android/components/geckoview/PromptCollection.sys.mjs43
-rw-r--r--mobile/android/components/geckoview/ShareDelegate.sys.mjs77
-rw-r--r--mobile/android/components/geckoview/components.conf107
-rw-r--r--mobile/android/components/geckoview/moz.build55
27 files changed, 3781 insertions, 0 deletions
diff --git a/mobile/android/components/geckoview/ColorPickerDelegate.sys.mjs b/mobile/android/components/geckoview/ColorPickerDelegate.sys.mjs
new file mode 100644
index 0000000000..dc1aff7629
--- /dev/null
+++ b/mobile/android/components/geckoview/ColorPickerDelegate.sys.mjs
@@ -0,0 +1,38 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("ColorPickerDelegate");
+
+export class ColorPickerDelegate {
+ // TODO(bug 1805397): Implement default colors
+ init(aParent, aTitle, aInitialColor, aDefaultColors) {
+ this._prompt = new lazy.GeckoViewPrompter(aParent);
+ this._msg = {
+ type: "color",
+ title: aTitle,
+ value: aInitialColor,
+ predefinedValues: aDefaultColors,
+ };
+ }
+
+ open(aColorPickerShownCallback) {
+ this._prompt.asyncShowPrompt(this._msg, result => {
+ // OK: result
+ // Cancel: !result
+ aColorPickerShownCallback.done((result && result.color) || "");
+ });
+ }
+}
+
+ColorPickerDelegate.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIColorPicker",
+]);
diff --git a/mobile/android/components/geckoview/FilePickerDelegate.sys.mjs b/mobile/android/components/geckoview/FilePickerDelegate.sys.mjs
new file mode 100644
index 0000000000..3972017b40
--- /dev/null
+++ b/mobile/android/components/geckoview/FilePickerDelegate.sys.mjs
@@ -0,0 +1,189 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("FilePickerDelegate");
+
+export class FilePickerDelegate {
+ /* ---------- nsIFilePicker ---------- */
+ init(aParent, aTitle, aMode) {
+ if (
+ aMode === Ci.nsIFilePicker.modeGetFolder ||
+ aMode === Ci.nsIFilePicker.modeSave
+ ) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ }
+ this._prompt = new lazy.GeckoViewPrompter(aParent);
+ this._msg = {
+ type: "file",
+ title: aTitle,
+ mode: aMode === Ci.nsIFilePicker.modeOpenMultiple ? "multiple" : "single",
+ };
+ this._mode = aMode;
+ this._mimeTypes = [];
+ this._capture = 0;
+ }
+
+ get mode() {
+ return this._mode;
+ }
+
+ appendRawFilter(aFilter) {
+ this._mimeTypes.push(aFilter);
+ }
+
+ show() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ }
+
+ open(aFilePickerShownCallback) {
+ this._msg.mimeTypes = this._mimeTypes;
+ this._msg.capture = this._capture;
+ this._prompt.asyncShowPrompt(this._msg, result => {
+ // OK: result
+ // Cancel: !result
+ if (!result || !result.files || !result.files.length) {
+ aFilePickerShownCallback.done(Ci.nsIFilePicker.returnCancel);
+ } else {
+ this._resolveFiles(result.files, aFilePickerShownCallback);
+ }
+ });
+ }
+
+ async _resolveFiles(aFiles, aCallback) {
+ const fileData = [];
+
+ try {
+ for (const file of aFiles) {
+ const domFile = await this._getDOMFile(file);
+ fileData.push({
+ file,
+ domFile,
+ });
+ }
+ } catch (ex) {
+ warn`Error resolving files from file picker: ${ex}`;
+ aCallback.done(Ci.nsIFilePicker.returnCancel);
+ return;
+ }
+
+ this._fileData = fileData;
+ aCallback.done(Ci.nsIFilePicker.returnOK);
+ }
+
+ get file() {
+ if (!this._fileData) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+ }
+ const fileData = this._fileData[0];
+ if (!fileData) {
+ return null;
+ }
+ return new lazy.FileUtils.File(fileData.file);
+ }
+
+ get fileURL() {
+ return Services.io.newFileURI(this.file);
+ }
+
+ *_getEnumerator(aDOMFile) {
+ if (!this._fileData) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+ }
+
+ for (const fileData of this._fileData) {
+ if (aDOMFile) {
+ yield fileData.domFile;
+ }
+ yield new lazy.FileUtils.File(fileData.file);
+ }
+ }
+
+ get files() {
+ return this._getEnumerator(/* aDOMFile */ false);
+ }
+
+ _getDOMFile(aPath) {
+ if (this._prompt.domWin) {
+ return this._prompt.domWin.File.createFromFileName(aPath);
+ }
+ return File.createFromFileName(aPath);
+ }
+
+ get domFileOrDirectory() {
+ if (!this._fileData) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+ }
+ return this._fileData[0] ? this._fileData[0].domFile : null;
+ }
+
+ get domFileOrDirectoryEnumerator() {
+ return this._getEnumerator(/* aDOMFile */ true);
+ }
+
+ get defaultString() {
+ return "";
+ }
+
+ set defaultString(aValue) {}
+
+ get defaultExtension() {
+ return "";
+ }
+
+ set defaultExtension(aValue) {}
+
+ get filterIndex() {
+ return 0;
+ }
+
+ set filterIndex(aValue) {}
+
+ get displayDirectory() {
+ return null;
+ }
+
+ set displayDirectory(aValue) {}
+
+ get displaySpecialDirectory() {
+ return "";
+ }
+
+ set displaySpecialDirectory(aValue) {}
+
+ get addToRecentDocs() {
+ return false;
+ }
+
+ set addToRecentDocs(aValue) {}
+
+ get okButtonLabel() {
+ return "";
+ }
+
+ set okButtonLabel(aValue) {}
+
+ get capture() {
+ return this._capture;
+ }
+
+ set capture(aValue) {
+ this._capture = aValue;
+ }
+}
+
+FilePickerDelegate.prototype.classID = Components.ID(
+ "{e4565e36-f101-4bf5-950b-4be0887785a9}"
+);
+FilePickerDelegate.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIFilePicker",
+]);
diff --git a/mobile/android/components/geckoview/GeckoView.manifest b/mobile/android/components/geckoview/GeckoView.manifest
new file mode 100644
index 0000000000..472c4d7298
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoView.manifest
@@ -0,0 +1,4 @@
+# GeckoViewStartup.js
+category app-startup GeckoViewStartup @mozilla.org/geckoview/startup;1 process=main
+category content-process-ready-for-script GeckoViewStartup @mozilla.org/geckoview/startup;1 process=content
+category profile-after-change GeckoViewStartup @mozilla.org/geckoview/startup;1 process=main
diff --git a/mobile/android/components/geckoview/GeckoViewContentChannel.cpp b/mobile/android/components/geckoview/GeckoViewContentChannel.cpp
new file mode 100644
index 0000000000..49236b074c
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewContentChannel.cpp
@@ -0,0 +1,47 @@
+/* -*- 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 "GeckoViewContentChannel.h"
+#include "GeckoViewInputStream.h"
+#include "mozilla/java/ContentInputStreamWrappers.h"
+
+using namespace mozilla;
+
+GeckoViewContentChannel::GeckoViewContentChannel(nsIURI* aURI) {
+ SetURI(aURI);
+ SetOriginalURI(aURI);
+}
+
+NS_IMETHODIMP
+GeckoViewContentChannel::OpenContentStream(bool aAsync,
+ nsIInputStream** aResult,
+ nsIChannel** aChannel) {
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, NS_ERROR_MALFORMED_URI);
+
+ nsAutoCString spec;
+ rv = uri->GetSpec(spec);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool isReadable = GeckoViewContentInputStream::isReadable(spec);
+ if (!isReadable) {
+ return NS_ERROR_FILE_NOT_FOUND;
+ }
+
+ nsCOMPtr<nsIInputStream> inputStream;
+ rv = GeckoViewContentInputStream::getInstance(spec,
+ getter_AddRefs(inputStream));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (NS_WARN_IF(!inputStream)) {
+ return NS_ERROR_MALFORMED_URI;
+ }
+
+ inputStream.forget(aResult);
+
+ return NS_OK;
+}
diff --git a/mobile/android/components/geckoview/GeckoViewContentChannel.h b/mobile/android/components/geckoview/GeckoViewContentChannel.h
new file mode 100644
index 0000000000..70252e7134
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewContentChannel.h
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cin: */
+/* 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 GeckoViewContentChannel_h__
+#define GeckoViewContentChannel_h__
+
+#include "nsBaseChannel.h"
+
+class GeckoViewContentChannel final : public nsBaseChannel {
+ public:
+ explicit GeckoViewContentChannel(nsIURI* aUri);
+
+ private:
+ ~GeckoViewContentChannel() = default;
+
+ nsresult OpenContentStream(bool async, nsIInputStream** result,
+ nsIChannel** channel) override;
+};
+
+#endif // !GeckoViewContentChannel_h__
diff --git a/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.cpp b/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.cpp
new file mode 100644
index 0000000000..dffd84e608
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.cpp
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:ts=4 sw=2 sts=2 et cin:
+/* 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 "GeckoViewContentProtocolHandler.h"
+#include "GeckoViewContentChannel.h"
+#include "nsStandardURL.h"
+#include "nsURLHelper.h"
+#include "nsIURIMutator.h"
+
+#include "nsNetUtil.h"
+
+#include "mozilla/ResultExtensions.h"
+
+//-----------------------------------------------------------------------------
+
+nsresult GeckoViewContentProtocolHandler::Init() { return NS_OK; }
+
+NS_IMPL_ISUPPORTS(GeckoViewContentProtocolHandler, nsIProtocolHandler,
+ nsISupportsWeakReference)
+
+//-----------------------------------------------------------------------------
+// nsIProtocolHandler methods:
+
+NS_IMETHODIMP
+GeckoViewContentProtocolHandler::GetScheme(nsACString& result) {
+ result.AssignLiteral("content");
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewContentProtocolHandler::NewChannel(nsIURI* uri, nsILoadInfo* aLoadInfo,
+ nsIChannel** result) {
+ nsresult rv;
+ RefPtr<GeckoViewContentChannel> chan = new GeckoViewContentChannel(uri);
+
+ rv = chan->SetLoadInfo(aLoadInfo);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ chan.forget(result);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewContentProtocolHandler::AllowPort(int32_t port, const char* scheme,
+ bool* result) {
+ // don't override anything.
+ *result = false;
+ return NS_OK;
+}
diff --git a/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.h b/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.h
new file mode 100644
index 0000000000..1763aaf121
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewContentProtocolHandler.h
@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 GeckoViewContentProtocolHandler_h__
+#define GeckoViewContentProtocolHandler_h__
+
+#include "nsIProtocolHandler.h"
+#include "nsWeakReference.h"
+
+class nsIURIMutator;
+
+class GeckoViewContentProtocolHandler : public nsIProtocolHandler,
+ public nsSupportsWeakReference {
+ virtual ~GeckoViewContentProtocolHandler() = default;
+
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIPROTOCOLHANDLER
+
+ GeckoViewContentProtocolHandler() = default;
+
+ [[nodiscard]] nsresult Init();
+};
+
+#endif // !GeckoViewContentProtocolHandler_h__
diff --git a/mobile/android/components/geckoview/GeckoViewExternalAppService.cpp b/mobile/android/components/geckoview/GeckoViewExternalAppService.cpp
new file mode 100644
index 0000000000..ffabd6ef2a
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewExternalAppService.cpp
@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 "GeckoViewExternalAppService.h"
+
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "nsIChannel.h"
+
+#include "mozilla/widget/EventDispatcher.h"
+#include "mozilla/widget/nsWindow.h"
+#include "GeckoViewStreamListener.h"
+
+#include "JavaBuiltins.h"
+
+class StreamListener final : public mozilla::GeckoViewStreamListener {
+ public:
+ explicit StreamListener(nsWindow* aWindow)
+ : GeckoViewStreamListener(), mWindow(aWindow) {}
+
+ void SendWebResponse(mozilla::java::WebResponse::Param aResponse) {
+ mWindow->PassExternalResponse(aResponse);
+ }
+
+ void CompleteWithError(nsresult aStatus, nsIChannel* aChannel) {
+ // Currently we don't do anything about errors here
+ }
+
+ virtual ~StreamListener() {}
+
+ private:
+ RefPtr<nsWindow> mWindow;
+};
+
+mozilla::StaticRefPtr<GeckoViewExternalAppService>
+ GeckoViewExternalAppService::sService;
+
+/* static */
+already_AddRefed<GeckoViewExternalAppService>
+GeckoViewExternalAppService::GetSingleton() {
+ if (!sService) {
+ sService = new GeckoViewExternalAppService();
+ }
+ RefPtr<GeckoViewExternalAppService> service = sService;
+ return service.forget();
+}
+
+GeckoViewExternalAppService::GeckoViewExternalAppService() {}
+
+NS_IMPL_ISUPPORTS(GeckoViewExternalAppService, nsIExternalHelperAppService);
+
+NS_IMETHODIMP GeckoViewExternalAppService::DoContent(
+ const nsACString& aMimeContentType, nsIChannel* aChannel,
+ nsIInterfaceRequestor* aContentContext, bool aForceSave,
+ nsIInterfaceRequestor* aWindowContext,
+ nsIStreamListener** aStreamListener) {
+ return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP GeckoViewExternalAppService::CreateListener(
+ const nsACString& aMimeContentType, nsIChannel* aChannel,
+ mozilla::dom::BrowsingContext* aContentContext, bool aForceSave,
+ nsIInterfaceRequestor* aWindowContext,
+ nsIStreamListener** aStreamListener) {
+ using namespace mozilla;
+ using namespace mozilla::dom;
+ MOZ_ASSERT(XRE_IsParentProcess());
+ NS_ENSURE_ARG_POINTER(aChannel);
+
+ nsCOMPtr<nsIWidget> widget =
+ aContentContext->Canonical()->GetParentProcessWidgetContaining();
+ if (!widget) {
+ return NS_ERROR_ABORT;
+ }
+
+ RefPtr<nsWindow> window = nsWindow::From(widget);
+ MOZ_ASSERT(window);
+
+ RefPtr<StreamListener> listener = new StreamListener(window);
+
+ nsresult rv;
+ rv = aChannel->SetNotificationCallbacks(listener);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ listener.forget(aStreamListener);
+ return NS_OK;
+}
+
+NS_IMETHODIMP GeckoViewExternalAppService::ApplyDecodingForExtension(
+ const nsACString& aExtension, const nsACString& aEncodingType,
+ bool* aApplyDecoding) {
+ // This currently doesn't matter, because we never read the stream.
+ *aApplyDecoding = true;
+ return NS_OK;
+}
diff --git a/mobile/android/components/geckoview/GeckoViewExternalAppService.h b/mobile/android/components/geckoview/GeckoViewExternalAppService.h
new file mode 100644
index 0000000000..1dfb7c9491
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewExternalAppService.h
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 GeckoViewExternalAppService_h__
+#define GeckoViewExternalAppService_h__
+
+#include "nsIExternalHelperAppService.h"
+#include "mozilla/StaticPtr.h"
+
+class GeckoViewExternalAppService : public nsIExternalHelperAppService {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIEXTERNALHELPERAPPSERVICE
+
+ GeckoViewExternalAppService();
+
+ static already_AddRefed<GeckoViewExternalAppService> GetSingleton();
+
+ private:
+ virtual ~GeckoViewExternalAppService() {}
+ static mozilla::StaticRefPtr<GeckoViewExternalAppService> sService;
+};
+
+#endif
diff --git a/mobile/android/components/geckoview/GeckoViewHistory.cpp b/mobile/android/components/geckoview/GeckoViewHistory.cpp
new file mode 100644
index 0000000000..c69e419b18
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewHistory.cpp
@@ -0,0 +1,508 @@
+/* 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 "GeckoViewHistory.h"
+
+#include "JavaBuiltins.h"
+#include "jsapi.h"
+#include "js/Array.h" // JS::GetArrayLength, JS::IsArrayObject
+#include "js/PropertyAndElement.h" // JS_GetElement
+#include "nsIURI.h"
+#include "nsXULAppAPI.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/StaticPrefs_layout.h"
+
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Link.h"
+#include "mozilla/dom/BrowserChild.h"
+
+#include "mozilla/ipc/URIUtils.h"
+
+#include "mozilla/widget/EventDispatcher.h"
+#include "mozilla/widget/nsWindow.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+using namespace mozilla::widget;
+
+static const char16_t kOnVisitedMessage[] = u"GeckoView:OnVisited";
+static const char16_t kGetVisitedMessage[] = u"GeckoView:GetVisited";
+
+// Keep in sync with `GeckoSession.HistoryDelegate.VisitFlags`.
+enum class GeckoViewVisitFlags : int32_t {
+ VISIT_TOP_LEVEL = 1 << 0,
+ VISIT_REDIRECT_TEMPORARY = 1 << 1,
+ VISIT_REDIRECT_PERMANENT = 1 << 2,
+ VISIT_REDIRECT_SOURCE = 1 << 3,
+ VISIT_REDIRECT_SOURCE_PERMANENT = 1 << 4,
+ VISIT_UNRECOVERABLE_ERROR = 1 << 5,
+};
+
+GeckoViewHistory::GeckoViewHistory() {}
+
+GeckoViewHistory::~GeckoViewHistory() {}
+
+NS_IMPL_ISUPPORTS(GeckoViewHistory, IHistory)
+
+StaticRefPtr<GeckoViewHistory> GeckoViewHistory::sHistory;
+
+/* static */
+already_AddRefed<GeckoViewHistory> GeckoViewHistory::GetSingleton() {
+ if (!sHistory) {
+ sHistory = new GeckoViewHistory();
+ ClearOnShutdown(&sHistory);
+ }
+ RefPtr<GeckoViewHistory> history = sHistory;
+ return history.forget();
+}
+
+// Handles a request to fetch visited statuses for new tracked URIs in the
+// content process (e10s).
+void GeckoViewHistory::QueryVisitedStateInContentProcess(
+ const PendingVisitedQueries& aQueries) {
+ // Holds an array of new tracked URIs for a tab in the content process.
+ struct NewURIEntry {
+ explicit NewURIEntry(BrowserChild* aBrowserChild, nsIURI* aURI)
+ : mBrowserChild(aBrowserChild) {
+ AddURI(aURI);
+ }
+
+ void AddURI(nsIURI* aURI) { mURIs.AppendElement(aURI); }
+
+ BrowserChild* mBrowserChild;
+ nsTArray<RefPtr<nsIURI>> mURIs;
+ };
+
+ MOZ_ASSERT(XRE_IsContentProcess());
+
+ // First, serialize all the new URIs that we need to look up. Note that this
+ // could be written as `nsTHashMap<nsUint64HashKey,
+ // nsTArray<URIParams>` instead, but, since we don't expect to have many tab
+ // children, we can avoid the cost of hashing.
+ AutoTArray<NewURIEntry, 8> newEntries;
+ for (auto& query : aQueries) {
+ nsIURI* uri = query.GetKey();
+ MOZ_ASSERT(query.GetData().IsEmpty(),
+ "Shouldn't have parents to notify in child processes");
+ auto entry = mTrackedURIs.Lookup(uri);
+ if (!entry) {
+ continue;
+ }
+ ObservingLinks& links = entry.Data();
+ for (Link* link : links.mLinks.BackwardRange()) {
+ nsIWidget* widget = nsContentUtils::WidgetForContent(link->GetElement());
+ if (!widget) {
+ continue;
+ }
+ BrowserChild* browserChild = widget->GetOwningBrowserChild();
+ if (!browserChild) {
+ continue;
+ }
+ // Add to the list of new URIs for this document, or make a new entry.
+ bool hasEntry = false;
+ for (NewURIEntry& entry : newEntries) {
+ if (entry.mBrowserChild == browserChild) {
+ entry.AddURI(uri);
+ hasEntry = true;
+ break;
+ }
+ }
+ if (!hasEntry) {
+ newEntries.AppendElement(NewURIEntry(browserChild, uri));
+ }
+ }
+ }
+
+ // Send the request to the parent process, one message per tab child.
+ for (const NewURIEntry& entry : newEntries) {
+ Unused << NS_WARN_IF(
+ !entry.mBrowserChild->SendQueryVisitedState(entry.mURIs));
+ }
+}
+
+// Handles a request to fetch visited statuses for new tracked URIs in the
+// parent process (non-e10s).
+void GeckoViewHistory::QueryVisitedStateInParentProcess(
+ const PendingVisitedQueries& aQueries) {
+ // Holds an array of new URIs for a window in the parent process. Unlike
+ // the content process case, we don't need to track tab children, since we
+ // have the outer window and can send the request directly to Java.
+ struct NewURIEntry {
+ explicit NewURIEntry(nsIWidget* aWidget, nsIURI* aURI) : mWidget(aWidget) {
+ AddURI(aURI);
+ }
+
+ void AddURI(nsIURI* aURI) { mURIs.AppendElement(aURI); }
+
+ nsCOMPtr<nsIWidget> mWidget;
+ nsTArray<RefPtr<nsIURI>> mURIs;
+ };
+
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ nsTArray<NewURIEntry> newEntries;
+ for (const auto& query : aQueries) {
+ nsIURI* uri = query.GetKey();
+ auto entry = mTrackedURIs.Lookup(uri);
+ if (!entry) {
+ continue; // Nobody cares about this uri anymore.
+ }
+
+ ObservingLinks& links = entry.Data();
+ nsTObserverArray<Link*>::BackwardIterator linksIter(links.mLinks);
+ while (linksIter.HasMore()) {
+ Link* link = linksIter.GetNext();
+
+ nsIWidget* widget = nsContentUtils::WidgetForContent(link->GetElement());
+ if (!widget) {
+ continue;
+ }
+
+ bool hasEntry = false;
+ for (NewURIEntry& entry : newEntries) {
+ if (entry.mWidget != widget) {
+ continue;
+ }
+ entry.AddURI(uri);
+ hasEntry = true;
+ }
+ if (!hasEntry) {
+ newEntries.AppendElement(NewURIEntry(widget, uri));
+ }
+ }
+ }
+
+ for (NewURIEntry& entry : newEntries) {
+ QueryVisitedState(entry.mWidget, nullptr, std::move(entry.mURIs));
+ }
+}
+
+void GeckoViewHistory::StartPendingVisitedQueries(
+ PendingVisitedQueries&& aQueries) {
+ if (XRE_IsContentProcess()) {
+ QueryVisitedStateInContentProcess(aQueries);
+ } else {
+ QueryVisitedStateInParentProcess(aQueries);
+ }
+}
+
+/**
+ * Called from the session handler for the history delegate, after the new
+ * visit is recorded.
+ */
+class OnVisitedCallback final : public nsIAndroidEventCallback {
+ public:
+ explicit OnVisitedCallback(GeckoViewHistory* aHistory, nsIURI* aURI)
+ : mHistory(aHistory), mURI(aURI) {}
+
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD
+ OnSuccess(JS::Handle<JS::Value> aData, JSContext* aCx) override {
+ Maybe<bool> visitedState = GetVisitedValue(aCx, aData);
+ JS_ClearPendingException(aCx);
+ if (visitedState) {
+ AutoTArray<VisitedURI, 1> visitedURIs;
+ visitedURIs.AppendElement(VisitedURI{mURI.get(), *visitedState});
+ mHistory->HandleVisitedState(visitedURIs, nullptr);
+ }
+ return NS_OK;
+ }
+
+ NS_IMETHOD
+ OnError(JS::Handle<JS::Value> aData, JSContext* aCx) override {
+ return NS_OK;
+ }
+
+ private:
+ virtual ~OnVisitedCallback() {}
+
+ Maybe<bool> GetVisitedValue(JSContext* aCx, JS::Handle<JS::Value> aData) {
+ if (NS_WARN_IF(!aData.isBoolean())) {
+ return Nothing();
+ }
+ return Some(aData.toBoolean());
+ }
+
+ RefPtr<GeckoViewHistory> mHistory;
+ nsCOMPtr<nsIURI> mURI;
+};
+
+NS_IMPL_ISUPPORTS(OnVisitedCallback, nsIAndroidEventCallback)
+
+NS_IMETHODIMP
+GeckoViewHistory::VisitURI(nsIWidget* aWidget, nsIURI* aURI,
+ nsIURI* aLastVisitedURI, uint32_t aFlags,
+ uint64_t aBrowserId) {
+ if (!aURI) {
+ return NS_OK;
+ }
+
+ if (XRE_IsContentProcess()) {
+ // If we're in the content process, send the visit to the parent. The parent
+ // will find the matching chrome window for the content process and tab,
+ // then forward the visit to Java.
+ if (NS_WARN_IF(!aWidget)) {
+ return NS_OK;
+ }
+ BrowserChild* browserChild = aWidget->GetOwningBrowserChild();
+ if (NS_WARN_IF(!browserChild)) {
+ return NS_OK;
+ }
+ Unused << NS_WARN_IF(
+ !browserChild->SendVisitURI(aURI, aLastVisitedURI, aFlags, aBrowserId));
+ return NS_OK;
+ }
+
+ // Otherwise, we're in the parent process. Wrap the URIs up in a bundle, and
+ // send them to Java.
+ MOZ_ASSERT(XRE_IsParentProcess());
+ RefPtr<nsWindow> window = nsWindow::From(aWidget);
+ if (NS_WARN_IF(!window)) {
+ return NS_OK;
+ }
+ widget::EventDispatcher* dispatcher = window->GetEventDispatcher();
+ if (NS_WARN_IF(!dispatcher)) {
+ return NS_OK;
+ }
+
+ // If nobody is listening for this, we can stop now.
+ if (!dispatcher->HasListener(kOnVisitedMessage)) {
+ return NS_OK;
+ }
+
+ AutoTArray<jni::String::LocalRef, 3> keys;
+ AutoTArray<jni::Object::LocalRef, 3> values;
+
+ nsAutoCString uriSpec;
+ if (NS_WARN_IF(NS_FAILED(aURI->GetSpec(uriSpec)))) {
+ return NS_OK;
+ }
+ keys.AppendElement(jni::StringParam(u"url"_ns));
+ values.AppendElement(jni::StringParam(uriSpec));
+
+ if (aLastVisitedURI) {
+ nsAutoCString lastVisitedURISpec;
+ if (NS_WARN_IF(NS_FAILED(aLastVisitedURI->GetSpec(lastVisitedURISpec)))) {
+ return NS_OK;
+ }
+ keys.AppendElement(jni::StringParam(u"lastVisitedURL"_ns));
+ values.AppendElement(jni::StringParam(lastVisitedURISpec));
+ }
+
+ int32_t flags = 0;
+ if (aFlags & TOP_LEVEL) {
+ flags |= static_cast<int32_t>(GeckoViewVisitFlags::VISIT_TOP_LEVEL);
+ }
+ if (aFlags & REDIRECT_TEMPORARY) {
+ flags |=
+ static_cast<int32_t>(GeckoViewVisitFlags::VISIT_REDIRECT_TEMPORARY);
+ }
+ if (aFlags & REDIRECT_PERMANENT) {
+ flags |=
+ static_cast<int32_t>(GeckoViewVisitFlags::VISIT_REDIRECT_PERMANENT);
+ }
+ if (aFlags & REDIRECT_SOURCE) {
+ flags |= static_cast<int32_t>(GeckoViewVisitFlags::VISIT_REDIRECT_SOURCE);
+ }
+ if (aFlags & REDIRECT_SOURCE_PERMANENT) {
+ flags |= static_cast<int32_t>(
+ GeckoViewVisitFlags::VISIT_REDIRECT_SOURCE_PERMANENT);
+ }
+ if (aFlags & UNRECOVERABLE_ERROR) {
+ flags |=
+ static_cast<int32_t>(GeckoViewVisitFlags::VISIT_UNRECOVERABLE_ERROR);
+ }
+ keys.AppendElement(jni::StringParam(u"flags"_ns));
+ values.AppendElement(java::sdk::Integer::ValueOf(flags));
+
+ MOZ_ASSERT(keys.Length() == values.Length());
+
+ auto bundleKeys = jni::ObjectArray::New<jni::String>(keys.Length());
+ auto bundleValues = jni::ObjectArray::New<jni::Object>(values.Length());
+ for (size_t i = 0; i < keys.Length(); ++i) {
+ bundleKeys->SetElement(i, keys[i]);
+ bundleValues->SetElement(i, values[i]);
+ }
+ auto bundle = java::GeckoBundle::New(bundleKeys, bundleValues);
+
+ nsCOMPtr<nsIAndroidEventCallback> callback =
+ new OnVisitedCallback(this, aURI);
+
+ Unused << NS_WARN_IF(
+ NS_FAILED(dispatcher->Dispatch(kOnVisitedMessage, bundle, callback)));
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewHistory::SetURITitle(nsIURI* aURI, const nsAString& aTitle) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/**
+ * Called from the session handler for the history delegate, with visited
+ * statuses for all requested URIs.
+ */
+class GetVisitedCallback final : public nsIAndroidEventCallback {
+ public:
+ explicit GetVisitedCallback(GeckoViewHistory* aHistory,
+ ContentParent* aInterestedProcess,
+ nsTArray<RefPtr<nsIURI>>&& aURIs)
+ : mHistory(aHistory),
+ mInterestedProcess(aInterestedProcess),
+ mURIs(std::move(aURIs)) {}
+
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD
+ OnSuccess(JS::Handle<JS::Value> aData, JSContext* aCx) override {
+ nsTArray<VisitedURI> visitedURIs;
+ if (!ExtractVisitedURIs(aCx, aData, visitedURIs)) {
+ JS_ClearPendingException(aCx);
+ return NS_ERROR_FAILURE;
+ }
+ IHistory::ContentParentSet interestedProcesses;
+ if (mInterestedProcess) {
+ interestedProcesses.Insert(mInterestedProcess);
+ }
+ mHistory->HandleVisitedState(visitedURIs, &interestedProcesses);
+ return NS_OK;
+ }
+
+ NS_IMETHOD
+ OnError(JS::Handle<JS::Value> aData, JSContext* aCx) override {
+ return NS_OK;
+ }
+
+ private:
+ virtual ~GetVisitedCallback() {}
+
+ /**
+ * Unpacks an array of Boolean visited statuses from the session handler into
+ * an array of `VisitedURI` structs. Each element in the array corresponds to
+ * a URI in `mURIs`.
+ *
+ * Returns `false` on error, `true` if the array is `null` or was successfully
+ * unpacked.
+ *
+ * TODO (bug 1503482): Remove this unboxing.
+ */
+ bool ExtractVisitedURIs(JSContext* aCx, JS::Handle<JS::Value> aData,
+ nsTArray<VisitedURI>& aVisitedURIs) {
+ if (aData.isNull()) {
+ return true;
+ }
+ bool isArray = false;
+ if (NS_WARN_IF(!JS::IsArrayObject(aCx, aData, &isArray))) {
+ return false;
+ }
+ if (NS_WARN_IF(!isArray)) {
+ return false;
+ }
+ JS::Rooted<JSObject*> visited(aCx, &aData.toObject());
+ uint32_t length = 0;
+ if (NS_WARN_IF(!JS::GetArrayLength(aCx, visited, &length))) {
+ return false;
+ }
+ if (NS_WARN_IF(length != mURIs.Length())) {
+ return false;
+ }
+ if (!aVisitedURIs.SetCapacity(length, mozilla::fallible)) {
+ return false;
+ }
+ for (uint32_t i = 0; i < length; ++i) {
+ JS::Rooted<JS::Value> value(aCx);
+ if (NS_WARN_IF(!JS_GetElement(aCx, visited, i, &value))) {
+ JS_ClearPendingException(aCx);
+ aVisitedURIs.AppendElement(VisitedURI{mURIs[i].get(), false});
+ continue;
+ }
+ if (NS_WARN_IF(!value.isBoolean())) {
+ aVisitedURIs.AppendElement(VisitedURI{mURIs[i].get(), false});
+ continue;
+ }
+ aVisitedURIs.AppendElement(VisitedURI{mURIs[i].get(), value.toBoolean()});
+ }
+ return true;
+ }
+
+ RefPtr<GeckoViewHistory> mHistory;
+ RefPtr<ContentParent> mInterestedProcess;
+ nsTArray<RefPtr<nsIURI>> mURIs;
+};
+
+NS_IMPL_ISUPPORTS(GetVisitedCallback, nsIAndroidEventCallback)
+
+/**
+ * Queries the history delegate to find which URIs have been visited. This
+ * is always called in the parent process: from `GetVisited` in non-e10s, and
+ * from `ContentParent::RecvGetVisited` in e10s.
+ */
+void GeckoViewHistory::QueryVisitedState(nsIWidget* aWidget,
+ ContentParent* aInterestedProcess,
+ nsTArray<RefPtr<nsIURI>>&& aURIs) {
+ MOZ_ASSERT(XRE_IsParentProcess());
+ RefPtr<nsWindow> window = nsWindow::From(aWidget);
+ if (NS_WARN_IF(!window)) {
+ return;
+ }
+ widget::EventDispatcher* dispatcher = window->GetEventDispatcher();
+ if (NS_WARN_IF(!dispatcher)) {
+ return;
+ }
+
+ // If nobody is listening for this we can stop now
+ if (!dispatcher->HasListener(kGetVisitedMessage)) {
+ return;
+ }
+
+ // Assemble a bundle like `{ urls: ["http://example.com/1", ...] }`.
+ auto uris = jni::ObjectArray::New<jni::String>(aURIs.Length());
+ for (size_t i = 0; i < aURIs.Length(); ++i) {
+ nsAutoCString uriSpec;
+ if (NS_WARN_IF(NS_FAILED(aURIs[i]->GetSpec(uriSpec)))) {
+ continue;
+ }
+ jni::String::LocalRef value{jni::StringParam(uriSpec)};
+ uris->SetElement(i, value);
+ }
+
+ auto bundleKeys = jni::ObjectArray::New<jni::String>(1);
+ jni::String::LocalRef key(jni::StringParam(u"urls"_ns));
+ bundleKeys->SetElement(0, key);
+
+ auto bundleValues = jni::ObjectArray::New<jni::Object>(1);
+ jni::Object::LocalRef value(uris);
+ bundleValues->SetElement(0, value);
+
+ auto bundle = java::GeckoBundle::New(bundleKeys, bundleValues);
+
+ nsCOMPtr<nsIAndroidEventCallback> callback =
+ new GetVisitedCallback(this, aInterestedProcess, std::move(aURIs));
+
+ Unused << NS_WARN_IF(
+ NS_FAILED(dispatcher->Dispatch(kGetVisitedMessage, bundle, callback)));
+}
+
+/**
+ * Updates link states for all tracked links, forwarding the visited statuses to
+ * the content process in e10s. This is always called in the parent process,
+ * from `VisitedCallback::OnSuccess` and `GetVisitedCallback::OnSuccess`.
+ */
+void GeckoViewHistory::HandleVisitedState(
+ const nsTArray<VisitedURI>& aVisitedURIs,
+ ContentParentSet* aInterestedProcesses) {
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ for (const VisitedURI& visitedURI : aVisitedURIs) {
+ auto status =
+ visitedURI.mVisited ? VisitedStatus::Visited : VisitedStatus::Unvisited;
+ NotifyVisited(visitedURI.mURI, status, aInterestedProcesses);
+ }
+}
diff --git a/mobile/android/components/geckoview/GeckoViewHistory.h b/mobile/android/components/geckoview/GeckoViewHistory.h
new file mode 100644
index 0000000000..a3b96ba58f
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewHistory.h
@@ -0,0 +1,60 @@
+/* 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 GECKOVIEWHISTORY_H
+#define GECKOVIEWHISTORY_H
+
+#include "mozilla/BaseHistory.h"
+#include "nsTObserverArray.h"
+#include "nsURIHashKey.h"
+#include "nsINamed.h"
+#include "nsITimer.h"
+#include "nsIURI.h"
+
+#include "mozilla/StaticPtr.h"
+
+class nsIWidget;
+
+namespace mozilla {
+namespace dom {
+class Document;
+}
+} // namespace mozilla
+
+struct VisitedURI {
+ nsCOMPtr<nsIURI> mURI;
+ bool mVisited = false;
+};
+
+class GeckoViewHistory final : public mozilla::BaseHistory {
+ public:
+ NS_DECL_ISUPPORTS
+
+ // IHistory
+ NS_IMETHOD VisitURI(nsIWidget*, nsIURI*, nsIURI* aLastVisitedURI,
+ uint32_t aFlags, uint64_t aBrowserId) final;
+ NS_IMETHOD SetURITitle(nsIURI*, const nsAString&) final;
+
+ static already_AddRefed<GeckoViewHistory> GetSingleton();
+
+ void StartPendingVisitedQueries(PendingVisitedQueries&&) final;
+
+ GeckoViewHistory();
+
+ void QueryVisitedState(nsIWidget* aWidget,
+ mozilla::dom::ContentParent* aInterestedProcess,
+ nsTArray<RefPtr<nsIURI>>&& aURIs);
+ void HandleVisitedState(const nsTArray<VisitedURI>& aVisitedURIs,
+ ContentParentSet* aInterestedProcesses);
+
+ private:
+ virtual ~GeckoViewHistory();
+
+ void QueryVisitedStateInContentProcess(const PendingVisitedQueries&);
+ void QueryVisitedStateInParentProcess(const PendingVisitedQueries&);
+
+ static mozilla::StaticRefPtr<GeckoViewHistory> sHistory;
+};
+
+#endif
diff --git a/mobile/android/components/geckoview/GeckoViewInputStream.cpp b/mobile/android/components/geckoview/GeckoViewInputStream.cpp
new file mode 100644
index 0000000000..187a0ce10c
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewInputStream.cpp
@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cin: */
+/* 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 "GeckoViewInputStream.h"
+#include "nsStreamUtils.h"
+
+NS_IMPL_ISUPPORTS(GeckoViewInputStream, nsIInputStream);
+
+NS_IMETHODIMP
+GeckoViewInputStream::Close() {
+ mClosed = true;
+ mInstance->Close();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewInputStream::Available(uint64_t* aCount) {
+ if (mClosed) {
+ return NS_BASE_STREAM_CLOSED;
+ }
+
+ *aCount = static_cast<uint64_t>(mInstance->Available());
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewInputStream::StreamStatus() {
+ return mClosed ? NS_BASE_STREAM_CLOSED : NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aReadCount) {
+ return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, aReadCount);
+}
+
+NS_IMETHODIMP
+GeckoViewInputStream::ReadSegments(nsWriteSegmentFun writer, void* aClosure,
+ uint32_t aCount, uint32_t* result) {
+ NS_ASSERTION(result, "null ptr");
+
+ if (mClosed) {
+ return NS_BASE_STREAM_CLOSED;
+ }
+
+ auto bufferAddress =
+ static_cast<const char*>(mInstance->MBuffer()->Address());
+ uint32_t segmentPos = static_cast<uint32_t>(mInstance->MPos());
+ int32_t dataLength = 0;
+ nsresult rv;
+
+ *result = 0;
+ while (aCount) {
+ rv = mInstance->Read(static_cast<int64_t>(aCount), &dataLength);
+ if (NS_FAILED(rv)) {
+ return NS_BASE_STREAM_OSERROR;
+ }
+
+ if (dataLength == -1) {
+ break;
+ }
+
+ uint32_t uDataLength = static_cast<uint32_t>(dataLength);
+ uint32_t written;
+ rv = writer(this, aClosure, bufferAddress + segmentPos, *result,
+ uDataLength, &written);
+
+ if (NS_FAILED(rv)) {
+ // InputStreams do not propagate errors to caller.
+ break;
+ }
+
+ NS_ASSERTION(written > 0, "Must have written something");
+
+ *result += written;
+ aCount -= written;
+
+ segmentPos = static_cast<uint32_t>(mInstance->ConsumedData(written));
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewInputStream::IsNonBlocking(bool* aNonBlocking) {
+ *aNonBlocking = true;
+ return NS_OK;
+}
+
+bool GeckoViewInputStream::isClosed() const { return mInstance->IsClosed(); }
+
+bool GeckoViewContentInputStream::isReadable(const nsAutoCString& aUri) {
+ return mozilla::java::ContentInputStream::IsReadable(
+ mozilla::jni::StringParam(aUri));
+}
+
+nsresult GeckoViewContentInputStream::getInstance(const nsAutoCString& aUri,
+ nsIInputStream** aInstance) {
+ RefPtr<GeckoViewContentInputStream> instance =
+ new GeckoViewContentInputStream(aUri);
+ if (instance->isClosed()) {
+ return NS_ERROR_FILE_NOT_FOUND;
+ }
+ *aInstance = instance.forget().take();
+
+ return NS_OK;
+}
diff --git a/mobile/android/components/geckoview/GeckoViewInputStream.h b/mobile/android/components/geckoview/GeckoViewInputStream.h
new file mode 100644
index 0000000000..ac48e0db25
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewInputStream.h
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cin: */
+/* 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 GeckoViewInputStream_h__
+#define GeckoViewInputStream_h__
+
+#include "mozilla/java/GeckoViewInputStreamWrappers.h"
+#include "mozilla/java/ContentInputStreamWrappers.h"
+#include "nsIInputStream.h"
+
+class GeckoViewInputStream : public nsIInputStream {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIINPUTSTREAM
+
+ explicit GeckoViewInputStream(
+ mozilla::java::GeckoViewInputStream::LocalRef aInstance)
+ : mInstance(aInstance){};
+ bool isClosed() const;
+
+ protected:
+ virtual ~GeckoViewInputStream() = default;
+
+ private:
+ mozilla::java::GeckoViewInputStream::LocalRef mInstance;
+ bool mClosed{false};
+};
+
+class GeckoViewContentInputStream final : public GeckoViewInputStream {
+ public:
+ static nsresult getInstance(const nsAutoCString& aUri,
+ nsIInputStream** aInstance);
+ static bool isReadable(const nsAutoCString& aUri);
+
+ private:
+ explicit GeckoViewContentInputStream(const nsAutoCString& aUri)
+ : GeckoViewInputStream(mozilla::java::ContentInputStream::GetInstance(
+ mozilla::jni::StringParam(aUri))) {}
+};
+
+#endif // !GeckoViewInputStream_h__
diff --git a/mobile/android/components/geckoview/GeckoViewOutputStream.cpp b/mobile/android/components/geckoview/GeckoViewOutputStream.cpp
new file mode 100644
index 0000000000..6368363f59
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewOutputStream.cpp
@@ -0,0 +1,61 @@
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil; -*-
+ * 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 "GeckoViewOutputStream.h"
+#include "mozilla/fallible.h"
+
+using namespace mozilla;
+
+NS_IMPL_ISUPPORTS(GeckoViewOutputStream, nsIOutputStream);
+
+NS_IMETHODIMP
+GeckoViewOutputStream::Close() {
+ mStream->SendEof();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewOutputStream::Flush() { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+GeckoViewOutputStream::StreamStatus() {
+ return mStream->IsStreamClosed() ? NS_BASE_STREAM_CLOSED : NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewOutputStream::Write(const char* buf, uint32_t count,
+ uint32_t* retval) {
+ jni::ByteArray::LocalRef buffer = jni::ByteArray::New(
+ reinterpret_cast<const int8_t*>(buf), count, fallible);
+ if (!buffer) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ if (NS_FAILED(mStream->AppendBuffer(buffer))) {
+ // The stream was closed, abort reading this channel.
+ return NS_BASE_STREAM_CLOSED;
+ }
+ // Return amount of bytes written
+ *retval = count;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewOutputStream::WriteFrom(nsIInputStream* fromStream, uint32_t count,
+ uint32_t* retval) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+GeckoViewOutputStream::WriteSegments(nsReadSegmentFun reader, void* closure,
+ uint32_t count, uint32_t* retval) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+GeckoViewOutputStream::IsNonBlocking(bool* retval) {
+ *retval = true;
+ return NS_OK;
+}
diff --git a/mobile/android/components/geckoview/GeckoViewOutputStream.h b/mobile/android/components/geckoview/GeckoViewOutputStream.h
new file mode 100644
index 0000000000..70ab8a9198
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewOutputStream.h
@@ -0,0 +1,29 @@
+
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil; -*-
+ * 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 GeckoViewOutputStream_h__
+#define GeckoViewOutputStream_h__
+
+#include "mozilla/java/GeckoInputStreamNatives.h"
+#include "mozilla/java/GeckoInputStreamWrappers.h"
+
+#include "nsIOutputStream.h"
+#include "nsIRequest.h"
+
+class GeckoViewOutputStream : public nsIOutputStream {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIOUTPUTSTREAM
+ explicit GeckoViewOutputStream(
+ mozilla::java::GeckoInputStream::GlobalRef aStream)
+ : mStream(aStream) {}
+
+ private:
+ const mozilla::java::GeckoInputStream::GlobalRef mStream;
+ virtual ~GeckoViewOutputStream() = default;
+};
+
+#endif // GeckoViewOutputStream_h__
diff --git a/mobile/android/components/geckoview/GeckoViewPermission.sys.mjs b/mobile/android/components/geckoview/GeckoViewPermission.sys.mjs
new file mode 100644
index 0000000000..51cc0f5588
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewPermission.sys.mjs
@@ -0,0 +1,36 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+export class GeckoViewPermission {
+ constructor() {
+ this.wrappedJSObject = this;
+ }
+
+ async prompt(aRequest) {
+ const window = aRequest.window
+ ? aRequest.window
+ : aRequest.element.ownerGlobal;
+
+ const actor = window.windowGlobalChild.getActor("GeckoViewPermission");
+ const result = await actor.promptPermission(aRequest);
+ if (!result.allow) {
+ aRequest.cancel();
+ } else {
+ // Note: permission could be undefined, that's what aRequest expects.
+ const { permission } = result;
+ aRequest.allow(permission);
+ }
+ }
+}
+
+GeckoViewPermission.prototype.classID = Components.ID(
+ "{42f3c238-e8e8-4015-9ca2-148723a8afcf}"
+);
+GeckoViewPermission.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIContentPermissionPrompt",
+]);
+
+const { debug, warn } = GeckoViewUtils.initLogging("GeckoViewPermission");
diff --git a/mobile/android/components/geckoview/GeckoViewPrompt.sys.mjs b/mobile/android/components/geckoview/GeckoViewPrompt.sys.mjs
new file mode 100644
index 0000000000..08087a4e63
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewPrompt.sys.mjs
@@ -0,0 +1,831 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs",
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+ GeckoViewClipboardPermission:
+ "resource://gre/modules/GeckoViewClipboardPermission.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("GeckoViewPrompt");
+
+export class PromptFactory {
+ constructor() {
+ this.wrappedJSObject = this;
+ }
+
+ handleEvent(aEvent) {
+ switch (aEvent.type) {
+ case "mozshowdropdown":
+ case "mozshowdropdown-sourcetouch":
+ this._handleSelect(
+ aEvent.composedTarget,
+ aEvent.composedTarget.isCombobox
+ );
+ break;
+ case "MozOpenDateTimePicker":
+ this._handleDateTime(aEvent.composedTarget);
+ break;
+ case "click":
+ this._handleClick(aEvent);
+ break;
+ case "DOMPopupBlocked":
+ this._handlePopupBlocked(aEvent);
+ break;
+ }
+ }
+
+ _handleClick(aEvent) {
+ const target = aEvent.composedTarget;
+ const className = ChromeUtils.getClassName(target);
+ if (className !== "HTMLInputElement" && className !== "HTMLSelectElement") {
+ return;
+ }
+
+ if (
+ target.isContentEditable ||
+ target.disabled ||
+ target.readOnly ||
+ !target.willValidate
+ ) {
+ // target.willValidate is false when any associated fieldset is disabled,
+ // in which case this element is treated as disabled per spec.
+ return;
+ }
+
+ if (className === "HTMLSelectElement") {
+ if (!target.isCombobox) {
+ this._handleSelect(target, /* aIsDropDown = */ false);
+ return;
+ }
+ // combobox select is handled by mozshowdropdown.
+ return;
+ }
+
+ const type = target.type;
+ if (type === "month" || type === "week") {
+ // If there's a shadow root, the MozOpenDateTimePicker event takes care
+ // of this. Right now for these input types there's never a shadow root.
+ // Once we support UA widgets for month/week inputs (see bug 888320), we
+ // can remove this.
+ if (!target.openOrClosedShadowRoot) {
+ this._handleDateTime(target);
+ aEvent.preventDefault();
+ }
+ }
+ }
+
+ _generateSelectItems(aElement) {
+ const win = aElement.ownerGlobal;
+ let id = 0;
+ const map = {};
+
+ const items = (function enumList(elem, disabled) {
+ const items = [];
+ const children = elem.children;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (win.getComputedStyle(child).display === "none") {
+ continue;
+ }
+ const item = {
+ id: String(id),
+ disabled: disabled || child.disabled,
+ };
+ if (win.HTMLOptGroupElement.isInstance(child)) {
+ item.label = child.label;
+ item.items = enumList(child, item.disabled);
+ } else if (win.HTMLOptionElement.isInstance(child)) {
+ item.label = child.label || child.text;
+ item.selected = child.selected;
+ } else if (win.HTMLHRElement.isInstance(child)) {
+ item.separator = true;
+ } else {
+ continue;
+ }
+ items.push(item);
+ map[id++] = child;
+ }
+ return items;
+ })(aElement);
+
+ return [items, map, id];
+ }
+
+ _handleSelect(aElement, aIsDropDown) {
+ const win = aElement.ownerGlobal;
+ const [items] = this._generateSelectItems(aElement);
+
+ if (aIsDropDown) {
+ aElement.openInParentProcess = true;
+ }
+
+ const prompt = new lazy.GeckoViewPrompter(win);
+
+ // Something changed the <select> while it was open.
+ const deferredUpdate = new lazy.DeferredTask(() => {
+ // Inner contents in choice prompt are updated.
+ const [newItems] = this._generateSelectItems(aElement);
+ prompt.update({
+ type: "choice",
+ mode: aElement.multiple ? "multiple" : "single",
+ choices: newItems,
+ });
+ }, 0);
+ const mut = new win.MutationObserver(() => {
+ deferredUpdate.arm();
+ });
+ mut.observe(aElement, {
+ childList: true,
+ subtree: true,
+ attributes: true,
+ });
+
+ const dismissPrompt = () => prompt.dismiss();
+ aElement.addEventListener("blur", dismissPrompt, { mozSystemGroup: true });
+ const hidedropdown = event => {
+ if (aElement === event.target) {
+ prompt.dismiss();
+ }
+ };
+ const chromeEventHandler = aElement.ownerGlobal.docShell.chromeEventHandler;
+ chromeEventHandler.addEventListener("mozhidedropdown", hidedropdown, {
+ mozSystemGroup: true,
+ });
+
+ prompt.asyncShowPrompt(
+ {
+ type: "choice",
+ mode: aElement.multiple ? "multiple" : "single",
+ choices: items,
+ },
+ result => {
+ deferredUpdate.disarm();
+ mut.disconnect();
+ aElement.removeEventListener("blur", dismissPrompt, {
+ mozSystemGroup: true,
+ });
+ chromeEventHandler.removeEventListener(
+ "mozhidedropdown",
+ hidedropdown,
+ { mozSystemGroup: true }
+ );
+
+ if (aIsDropDown) {
+ aElement.openInParentProcess = false;
+ }
+ // OK: result
+ // Cancel: !result
+ if (!result || result.choices === undefined) {
+ return;
+ }
+
+ const [, map, id] = this._generateSelectItems(aElement);
+ let dispatchEvents = false;
+ if (!aElement.multiple) {
+ const elem = map[result.choices[0]];
+ if (elem && win.HTMLOptionElement.isInstance(elem)) {
+ dispatchEvents = !elem.selected;
+ elem.selected = true;
+ } else {
+ console.error("Invalid id for select result: " + result.choices[0]);
+ }
+ } else {
+ for (let i = 0; i < id; i++) {
+ const elem = map[i];
+ const index = result.choices.indexOf(String(i));
+ if (
+ win.HTMLOptionElement.isInstance(elem) &&
+ elem.selected !== index >= 0
+ ) {
+ // Current selected is not the same as the new selected state.
+ dispatchEvents = true;
+ elem.selected = !elem.selected;
+ }
+ result.choices[index] = undefined;
+ }
+ for (let i = 0; i < result.choices.length; i++) {
+ if (result.choices[i] !== undefined && result.choices[i] !== null) {
+ console.error(
+ "Invalid id for select result: " + result.choices[i]
+ );
+ break;
+ }
+ }
+ }
+
+ if (dispatchEvents) {
+ this._dispatchEvents(aElement);
+ }
+ }
+ );
+ }
+
+ _handleDateTime(aElement) {
+ const win = aElement.ownerGlobal;
+ const prompt = new lazy.GeckoViewPrompter(win);
+
+ const chromeEventHandler = aElement.ownerGlobal.docShell.chromeEventHandler;
+ const dismissPrompt = () => prompt.dismiss();
+ // Some controls don't have UA widget (bug 888320)
+ {
+ const dateTimeBoxElement = aElement.dateTimeBoxElement;
+ if (["month", "week"].includes(aElement.type) && !dateTimeBoxElement) {
+ aElement.addEventListener("blur", dismissPrompt, {
+ mozSystemGroup: true,
+ });
+ } else {
+ chromeEventHandler.addEventListener(
+ "MozCloseDateTimePicker",
+ dismissPrompt
+ );
+
+ dateTimeBoxElement.dispatchEvent(
+ new win.CustomEvent("MozSetDateTimePickerState", { detail: true })
+ );
+ }
+ }
+
+ prompt.asyncShowPrompt(
+ {
+ type: "datetime",
+ mode: aElement.type,
+ value: aElement.value,
+ min: aElement.min,
+ max: aElement.max,
+ step: aElement.step,
+ },
+ result => {
+ // Some controls don't have UA widget (bug 888320)
+ const dateTimeBoxElement = aElement.dateTimeBoxElement;
+ if (["month", "week"].includes(aElement.type) && !dateTimeBoxElement) {
+ aElement.removeEventListener("blur", dismissPrompt, {
+ mozSystemGroup: true,
+ });
+ } else {
+ chromeEventHandler.removeEventListener(
+ "MozCloseDateTimePicker",
+ dismissPrompt
+ );
+ dateTimeBoxElement.dispatchEvent(
+ new win.CustomEvent("MozSetDateTimePickerState", { detail: false })
+ );
+ }
+
+ // OK: result
+ // Cancel: !result
+ if (
+ !result ||
+ result.datetime === undefined ||
+ result.datetime === aElement.value
+ ) {
+ return;
+ }
+ aElement.value = result.datetime;
+ this._dispatchEvents(aElement);
+ }
+ );
+ }
+
+ _dispatchEvents(aElement) {
+ // Fire both "input" and "change" events for <select> and <input> for
+ // date/time.
+ aElement.dispatchEvent(
+ new aElement.ownerGlobal.Event("input", { bubbles: true, composed: true })
+ );
+ aElement.dispatchEvent(
+ new aElement.ownerGlobal.Event("change", { bubbles: true })
+ );
+ }
+
+ _handlePopupBlocked(aEvent) {
+ const dwi = aEvent.requestingWindow;
+ const popupWindowURISpec = aEvent.popupWindowURI
+ ? aEvent.popupWindowURI.displaySpec
+ : "about:blank";
+
+ const prompt = new lazy.GeckoViewPrompter(aEvent.requestingWindow);
+ prompt.asyncShowPrompt(
+ {
+ type: "popup",
+ targetUri: popupWindowURISpec,
+ },
+ ({ response }) => {
+ if (response && dwi) {
+ dwi.open(
+ popupWindowURISpec,
+ aEvent.popupWindowName,
+ aEvent.popupWindowFeatures
+ );
+ }
+ }
+ );
+ }
+
+ /* ---------- nsIPromptFactory ---------- */
+ getPrompt(aDOMWin, aIID) {
+ // Delegated to login manager here, which in turn calls back into us via nsIPromptService.
+ if (aIID.equals(Ci.nsIAuthPrompt2) || aIID.equals(Ci.nsIAuthPrompt)) {
+ try {
+ const pwmgr = Cc[
+ "@mozilla.org/passwordmanager/authpromptfactory;1"
+ ].getService(Ci.nsIPromptFactory);
+ return pwmgr.getPrompt(aDOMWin, aIID);
+ } catch (e) {
+ console.error("Delegation to password manager failed:", e);
+ }
+ }
+
+ const p = new PromptDelegate(aDOMWin);
+ p.QueryInterface(aIID);
+ return p;
+ }
+
+ /* ---------- private memebers ---------- */
+
+ // nsIPromptService methods proxy to our Prompt class
+ callProxy(aMethod, aArguments) {
+ const prompt = new PromptDelegate(aArguments[0]);
+ let promptArgs;
+ if (BrowsingContext.isInstance(aArguments[0])) {
+ // Called by BrowsingContext prompt method, strip modalType.
+ [, , /*browsingContext*/ /*modalType*/ ...promptArgs] = aArguments;
+ } else {
+ [, /*domWindow*/ ...promptArgs] = aArguments;
+ }
+ return prompt[aMethod].apply(prompt, promptArgs);
+ }
+
+ /* ---------- nsIPromptService ---------- */
+
+ alert() {
+ return this.callProxy("alert", arguments);
+ }
+ alertBC() {
+ return this.callProxy("alert", arguments);
+ }
+ alertCheck() {
+ return this.callProxy("alertCheck", arguments);
+ }
+ alertCheckBC() {
+ return this.callProxy("alertCheck", arguments);
+ }
+ confirm() {
+ return this.callProxy("confirm", arguments);
+ }
+ confirmBC() {
+ return this.callProxy("confirm", arguments);
+ }
+ confirmCheck() {
+ return this.callProxy("confirmCheck", arguments);
+ }
+ confirmCheckBC() {
+ return this.callProxy("confirmCheck", arguments);
+ }
+ confirmEx() {
+ return this.callProxy("confirmEx", arguments);
+ }
+ confirmExBC() {
+ return this.callProxy("confirmEx", arguments);
+ }
+ prompt() {
+ return this.callProxy("prompt", arguments);
+ }
+ promptBC() {
+ return this.callProxy("prompt", arguments);
+ }
+ promptUsernameAndPassword() {
+ return this.callProxy("promptUsernameAndPassword", arguments);
+ }
+ promptUsernameAndPasswordBC() {
+ return this.callProxy("promptUsernameAndPassword", arguments);
+ }
+ promptPassword() {
+ return this.callProxy("promptPassword", arguments);
+ }
+ promptPasswordBC() {
+ return this.callProxy("promptPassword", arguments);
+ }
+ select() {
+ return this.callProxy("select", arguments);
+ }
+ selectBC() {
+ return this.callProxy("select", arguments);
+ }
+ promptAuth() {
+ return this.callProxy("promptAuth", arguments);
+ }
+ promptAuthBC() {
+ return this.callProxy("promptAuth", arguments);
+ }
+ asyncPromptAuth() {
+ return this.callProxy("asyncPromptAuth", arguments);
+ }
+ confirmUserPaste() {
+ return lazy.GeckoViewClipboardPermission.confirmUserPaste(...arguments);
+ }
+}
+
+PromptFactory.prototype.classID = Components.ID(
+ "{076ac188-23c1-4390-aa08-7ef1f78ca5d9}"
+);
+PromptFactory.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIPromptFactory",
+ "nsIPromptService",
+]);
+
+class PromptDelegate {
+ constructor(aParent) {
+ this._prompter = new lazy.GeckoViewPrompter(aParent);
+ }
+
+ BUTTON_TYPE_POSITIVE = 0;
+ BUTTON_TYPE_NEUTRAL = 1;
+ BUTTON_TYPE_NEGATIVE = 2;
+
+ /* ---------- internal methods ---------- */
+
+ _addText(aTitle, aText, aMsg) {
+ return Object.assign(aMsg, {
+ title: aTitle,
+ msg: aText,
+ });
+ }
+
+ _addCheck(aCheckMsg, aCheckState, aMsg) {
+ return Object.assign(aMsg, {
+ hasCheck: !!aCheckMsg,
+ checkMsg: aCheckMsg,
+ checkValue: aCheckState && aCheckState.value,
+ });
+ }
+
+ /* ---------- nsIPrompt ---------- */
+
+ alert(aTitle, aText) {
+ this.alertCheck(aTitle, aText);
+ }
+
+ alertCheck(aTitle, aText, aCheckMsg, aCheckState) {
+ const result = this._prompter.showPrompt(
+ this._addText(
+ aTitle,
+ aText,
+ this._addCheck(aCheckMsg, aCheckState, {
+ type: "alert",
+ })
+ )
+ );
+ if (result && aCheckState) {
+ aCheckState.value = !!result.checkValue;
+ }
+ }
+
+ confirm(aTitle, aText) {
+ // Button 0 is OK.
+ return this.confirmCheck(aTitle, aText);
+ }
+
+ confirmCheck(aTitle, aText, aCheckMsg, aCheckState) {
+ // Button 0 is OK.
+ return (
+ this.confirmEx(
+ aTitle,
+ aText,
+ Ci.nsIPrompt.STD_OK_CANCEL_BUTTONS,
+ /* aButton0 */ null,
+ /* aButton1 */ null,
+ /* aButton2 */ null,
+ aCheckMsg,
+ aCheckState
+ ) == 0
+ );
+ }
+
+ confirmEx(
+ aTitle,
+ aText,
+ aButtonFlags,
+ aButton0,
+ aButton1,
+ aButton2,
+ aCheckMsg,
+ aCheckState
+ ) {
+ const btnMap = Array(3).fill(null);
+ const btnTitle = Array(3).fill(null);
+ const btnCustomTitle = Array(3).fill(null);
+ const savedButtonId = [];
+ for (let i = 0; i < 3; i++) {
+ const btnFlags = aButtonFlags >> (i * 8);
+ switch (btnFlags & 0xff) {
+ case Ci.nsIPrompt.BUTTON_TITLE_OK:
+ btnMap[this.BUTTON_TYPE_POSITIVE] = i;
+ btnTitle[this.BUTTON_TYPE_POSITIVE] = "ok";
+ break;
+ case Ci.nsIPrompt.BUTTON_TITLE_CANCEL:
+ btnMap[this.BUTTON_TYPE_NEGATIVE] = i;
+ btnTitle[this.BUTTON_TYPE_NEGATIVE] = "cancel";
+ break;
+ case Ci.nsIPrompt.BUTTON_TITLE_YES:
+ btnMap[this.BUTTON_TYPE_POSITIVE] = i;
+ btnTitle[this.BUTTON_TYPE_POSITIVE] = "yes";
+ break;
+ case Ci.nsIPrompt.BUTTON_TITLE_NO:
+ btnMap[this.BUTTON_TYPE_NEGATIVE] = i;
+ btnTitle[this.BUTTON_TYPE_NEGATIVE] = "no";
+ break;
+ case Ci.nsIPrompt.BUTTON_TITLE_IS_STRING:
+ // We don't know if this is positive/negative/neutral, so save for later.
+ savedButtonId.push(i);
+ break;
+ case Ci.nsIPrompt.BUTTON_TITLE_SAVE:
+ case Ci.nsIPrompt.BUTTON_TITLE_DONT_SAVE:
+ case Ci.nsIPrompt.BUTTON_TITLE_REVERT:
+ // Not supported; fall-through.
+ default:
+ break;
+ }
+ }
+
+ // Put saved buttons into available slots.
+ for (let i = 0; i < 3 && savedButtonId.length; i++) {
+ if (btnMap[i] === null) {
+ btnMap[i] = savedButtonId.shift();
+ btnTitle[i] = "custom";
+ btnCustomTitle[i] = [aButton0, aButton1, aButton2][btnMap[i]];
+ }
+ }
+
+ const result = this._prompter.showPrompt(
+ this._addText(
+ aTitle,
+ aText,
+ this._addCheck(aCheckMsg, aCheckState, {
+ type: "button",
+ btnTitle,
+ btnCustomTitle,
+ })
+ )
+ );
+ if (result && aCheckState) {
+ aCheckState.value = !!result.checkValue;
+ }
+ return result && result.button in btnMap ? btnMap[result.button] : -1;
+ }
+
+ prompt(aTitle, aText, aValue, aCheckMsg, aCheckState) {
+ const result = this._prompter.showPrompt(
+ this._addText(
+ aTitle,
+ aText,
+ this._addCheck(aCheckMsg, aCheckState, {
+ type: "text",
+ value: aValue.value,
+ })
+ )
+ );
+ // OK: result && result.text !== undefined
+ // Cancel: result && result.text === undefined
+ // Error: !result
+ if (result && aCheckState) {
+ aCheckState.value = !!result.checkValue;
+ }
+ if (!result || result.text === undefined) {
+ return false;
+ }
+ aValue.value = result.text || "";
+ return true;
+ }
+
+ promptPassword(aTitle, aText, aPassword) {
+ return this._promptUsernameAndPassword(
+ aTitle,
+ aText,
+ /* aUsername */ undefined,
+ aPassword
+ );
+ }
+
+ promptUsernameAndPassword(aTitle, aText, aUsername, aPassword) {
+ const msg = {
+ type: "auth",
+ mode: aUsername ? "auth" : "password",
+ options: {
+ flags: aUsername ? 0 : Ci.nsIAuthInformation.ONLY_PASSWORD,
+ username: aUsername ? aUsername.value : undefined,
+ password: aPassword.value,
+ },
+ };
+ const result = this._prompter.showPrompt(this._addText(aTitle, aText, msg));
+ // OK: result && result.password !== undefined
+ // Cancel: result && result.password === undefined
+ // Error: !result
+ if (!result || result.password === undefined) {
+ return false;
+ }
+ if (aUsername) {
+ aUsername.value = result.username || "";
+ }
+ aPassword.value = result.password || "";
+ return true;
+ }
+
+ select(aTitle, aText, aSelectList, aOutSelection) {
+ const choices = Array.prototype.map.call(aSelectList, (item, index) => ({
+ id: String(index),
+ label: item,
+ disabled: false,
+ selected: false,
+ }));
+ const result = this._prompter.showPrompt(
+ this._addText(aTitle, aText, {
+ type: "choice",
+ mode: "single",
+ choices,
+ })
+ );
+ // OK: result
+ // Cancel: !result
+ if (!result || result.choices === undefined) {
+ return false;
+ }
+ aOutSelection.value = Number(result.choices[0]);
+ return true;
+ }
+
+ _getAuthMsg(aChannel, aLevel, aAuthInfo) {
+ let username;
+ if (
+ aAuthInfo.flags & Ci.nsIAuthInformation.NEED_DOMAIN &&
+ aAuthInfo.domain
+ ) {
+ username = aAuthInfo.domain + "\\" + aAuthInfo.username;
+ } else {
+ username = aAuthInfo.username;
+ }
+ return this._addText(
+ /* title */ null,
+ this._getAuthText(aChannel, aAuthInfo),
+ {
+ type: "auth",
+ mode:
+ aAuthInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD
+ ? "password"
+ : "auth",
+ options: {
+ flags: aAuthInfo.flags,
+ uri: aChannel && aChannel.URI.displaySpec,
+ level: aLevel,
+ username,
+ password: aAuthInfo.password,
+ },
+ }
+ );
+ }
+
+ _fillAuthInfo(aAuthInfo, aResult) {
+ if (!aResult || aResult.password === undefined) {
+ return false;
+ }
+
+ aAuthInfo.password = aResult.password || "";
+ if (aAuthInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD) {
+ return true;
+ }
+
+ const username = aResult.username || "";
+ if (aAuthInfo.flags & Ci.nsIAuthInformation.NEED_DOMAIN) {
+ // Domain is separated from username by a backslash
+ var idx = username.indexOf("\\");
+ if (idx >= 0) {
+ aAuthInfo.domain = username.substring(0, idx);
+ aAuthInfo.username = username.substring(idx + 1);
+ return true;
+ }
+ }
+ aAuthInfo.username = username;
+ return true;
+ }
+
+ promptAuth(aChannel, aLevel, aAuthInfo) {
+ const result = this._prompter.showPrompt(
+ this._getAuthMsg(aChannel, aLevel, aAuthInfo)
+ );
+ // OK: result && result.password !== undefined
+ // Cancel: result && result.password === undefined
+ // Error: !result
+ return this._fillAuthInfo(aAuthInfo, result);
+ }
+
+ async asyncPromptAuth(aChannel, aLevel, aAuthInfo) {
+ const result = await this._prompter.asyncShowPromptPromise(
+ this._getAuthMsg(aChannel, aLevel, aAuthInfo)
+ );
+ // OK: result && result.password !== undefined
+ // Cancel: result && result.password === undefined
+ // Error: !result
+ return this._fillAuthInfo(aAuthInfo, result);
+ }
+
+ _getAuthText(aChannel, aAuthInfo) {
+ const isProxy = aAuthInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY;
+ const isPassOnly = aAuthInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD;
+ const isCrossOrig =
+ aAuthInfo.flags & Ci.nsIAuthInformation.CROSS_ORIGIN_SUB_RESOURCE;
+
+ const username = aAuthInfo.username;
+ const authTarget = this._getAuthTarget(aChannel, aAuthInfo);
+ const { displayHost } = authTarget;
+ let { realm } = authTarget;
+
+ // Suppress "the site says: $realm" when we synthesized a missing realm.
+ if (!aAuthInfo.realm && !isProxy) {
+ realm = "";
+ }
+
+ // Trim obnoxiously long realms.
+ if (realm.length > 50) {
+ realm = realm.substring(0, 50) + "\u2026";
+ }
+
+ const bundle = Services.strings.createBundle(
+ "chrome://global/locale/commonDialogs.properties"
+ );
+ let text;
+ if (isProxy) {
+ text = bundle.formatStringFromName("EnterLoginForProxy3", [
+ realm,
+ displayHost,
+ ]);
+ } else if (isPassOnly) {
+ text = bundle.formatStringFromName("EnterPasswordFor", [
+ username,
+ displayHost,
+ ]);
+ } else if (isCrossOrig) {
+ text = bundle.formatStringFromName("EnterUserPasswordForCrossOrigin2", [
+ displayHost,
+ ]);
+ } else if (!realm) {
+ text = bundle.formatStringFromName("EnterUserPasswordFor2", [
+ displayHost,
+ ]);
+ } else {
+ text = bundle.formatStringFromName("EnterLoginForRealm3", [
+ realm,
+ displayHost,
+ ]);
+ }
+
+ return text;
+ }
+
+ _getAuthTarget(aChannel, aAuthInfo) {
+ // If our proxy is demanding authentication, don't use the
+ // channel's actual destination.
+ if (aAuthInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY) {
+ if (!(aChannel instanceof Ci.nsIProxiedChannel)) {
+ throw new Error("proxy auth needs nsIProxiedChannel");
+ }
+ const info = aChannel.proxyInfo;
+ if (!info) {
+ throw new Error("proxy auth needs nsIProxyInfo");
+ }
+ // Proxies don't have a scheme, but we'll use "moz-proxy://"
+ // so that it's more obvious what the login is for.
+ const idnService = Cc["@mozilla.org/network/idn-service;1"].getService(
+ Ci.nsIIDNService
+ );
+ const displayHost =
+ "moz-proxy://" +
+ idnService.convertUTF8toACE(info.host) +
+ ":" +
+ info.port;
+ let realm = aAuthInfo.realm;
+ if (!realm) {
+ realm = displayHost;
+ }
+ return { displayHost, realm };
+ }
+
+ const displayHost =
+ aChannel.URI.scheme + "://" + aChannel.URI.displayHostPort;
+ // If a HTTP WWW-Authenticate header specified a realm, that value
+ // will be available here. If it wasn't set or wasn't HTTP, we'll use
+ // the formatted hostname instead.
+ let realm = aAuthInfo.realm;
+ if (!realm) {
+ realm = displayHost;
+ }
+ return { displayHost, realm };
+ }
+}
+
+PromptDelegate.prototype.QueryInterface = ChromeUtils.generateQI(["nsIPrompt"]);
diff --git a/mobile/android/components/geckoview/GeckoViewPrompter.sys.mjs b/mobile/android/components/geckoview/GeckoViewPrompter.sys.mjs
new file mode 100644
index 0000000000..f81c155678
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewPrompter.sys.mjs
@@ -0,0 +1,206 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const { debug, warn } = GeckoViewUtils.initLogging("GeckoViewPrompter");
+
+export class GeckoViewPrompter {
+ constructor(aParent) {
+ this.id = Services.uuid.generateUUID().toString().slice(1, -1); // Discard surrounding braces
+
+ if (aParent) {
+ if (Window.isInstance(aParent)) {
+ this._domWin = aParent;
+ } else if (aParent.window) {
+ this._domWin = aParent.window;
+ } else {
+ this._domWin =
+ aParent.embedderElement && aParent.embedderElement.ownerGlobal;
+ }
+ }
+
+ if (!this._domWin) {
+ this._domWin = Services.wm.getMostRecentWindow("navigator:geckoview");
+ }
+
+ this._innerWindowId =
+ this._domWin?.browsingContext.currentWindowContext.innerWindowId;
+ }
+
+ get domWin() {
+ return this._domWin;
+ }
+
+ get prompterActor() {
+ const actor = this.domWin?.windowGlobalChild.getActor("GeckoViewPrompter");
+ return actor;
+ }
+
+ _changeModalState(aEntering) {
+ if (!this._domWin) {
+ // Allow not having a DOM window.
+ return true;
+ }
+ // Accessing the document object can throw if this window no longer exists. See bug 789888.
+ try {
+ const winUtils = this._domWin.windowUtils;
+ if (!aEntering) {
+ winUtils.leaveModalState();
+ }
+
+ const event = this._domWin.document.createEvent("Events");
+ event.initEvent(
+ aEntering ? "DOMWillOpenModalDialog" : "DOMModalDialogClosed",
+ true,
+ true
+ );
+ winUtils.dispatchEventToChromeOnly(this._domWin, event);
+
+ if (aEntering) {
+ winUtils.enterModalState();
+ }
+ return true;
+ } catch (ex) {
+ console.error("Failed to change modal state:", ex);
+ }
+ return false;
+ }
+
+ _dismissUi() {
+ this.prompterActor?.dismissPrompt(this);
+ }
+
+ accept(aInputText = this.inputText) {
+ if (this.callback) {
+ let acceptMsg = {};
+ switch (this.message.type) {
+ case "alert":
+ acceptMsg = null;
+ break;
+ case "button":
+ acceptMsg.button = 0;
+ break;
+ case "text":
+ acceptMsg.text = aInputText;
+ break;
+ default:
+ acceptMsg = null;
+ break;
+ }
+ this.callback(acceptMsg);
+ // Notify the UI that this prompt should be hidden.
+ this._dismissUi();
+ }
+ }
+
+ dismiss() {
+ this.callback(null);
+ // Notify the UI that this prompt should be hidden.
+ this._dismissUi();
+ }
+
+ getPromptType() {
+ switch (this.message.type) {
+ case "alert":
+ return this.message.checkValue ? "alertCheck" : "alert";
+ case "button":
+ return this.message.checkValue ? "confirmCheck" : "confirm";
+ case "text":
+ return this.message.checkValue ? "promptCheck" : "prompt";
+ default:
+ return this.message.type;
+ }
+ }
+
+ getPromptText() {
+ return this.message.msg;
+ }
+
+ getInputText() {
+ return this.inputText;
+ }
+
+ setInputText(aInput) {
+ this.inputText = aInput;
+ }
+
+ /**
+ * Shows a native prompt, and then spins the event loop for this thread while we wait
+ * for a response
+ */
+ showPrompt(aMsg) {
+ let result = undefined;
+ if (!this._domWin || !this._changeModalState(/* aEntering */ true)) {
+ return result;
+ }
+ try {
+ this.asyncShowPrompt(aMsg, res => (result = res));
+
+ // Spin this thread while we wait for a result
+ Services.tm.spinEventLoopUntil(
+ "GeckoViewPrompter.jsm:showPrompt",
+ () => this._domWin.closed || result !== undefined
+ );
+ } finally {
+ this._changeModalState(/* aEntering */ false);
+ }
+ return result;
+ }
+
+ checkInnerWindow() {
+ // Checks that the innerWindow where this prompt was created still matches
+ // the current innerWindow.
+ // This checks will fail if the page navigates away, making this prompt
+ // obsolete.
+ return (
+ this._innerWindowId ===
+ this._domWin.browsingContext.currentWindowContext.innerWindowId
+ );
+ }
+
+ asyncShowPromptPromise(aMsg) {
+ return new Promise(resolve => {
+ this.asyncShowPrompt(aMsg, resolve);
+ });
+ }
+
+ async asyncShowPrompt(aMsg, aCallback) {
+ this.message = aMsg;
+ this.inputText = aMsg.value;
+ this.callback = aCallback;
+
+ aMsg.id = this.id;
+
+ let response = null;
+ try {
+ if (this.checkInnerWindow()) {
+ response = await this.prompterActor.prompt(this, aMsg);
+ }
+ } catch (error) {
+ // Nothing we can do really, we will treat this as a dismiss.
+ warn`Error while prompting: ${error}`;
+ }
+
+ if (!this.checkInnerWindow()) {
+ // Page has navigated away, let's dismiss the prompt
+ aCallback(null);
+ } else {
+ aCallback(response);
+ }
+ // This callback object is tied to the Java garbage collector because
+ // it is invoked from Java. Manually release the target callback
+ // here; otherwise we may hold onto resources for too long, because
+ // we would be relying on both the Java and the JS garbage collectors
+ // to run.
+ aMsg = undefined;
+ aCallback = undefined;
+ }
+
+ update(aMsg) {
+ this.message = aMsg;
+ aMsg.id = this.id;
+ this.prompterActor?.updatePrompt(aMsg);
+ }
+}
diff --git a/mobile/android/components/geckoview/GeckoViewPush.sys.mjs b/mobile/android/components/geckoview/GeckoViewPush.sys.mjs
new file mode 100644
index 0000000000..d6625942e8
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewPush.sys.mjs
@@ -0,0 +1,264 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const { debug, warn } = GeckoViewUtils.initLogging("GeckoViewPush");
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ EventDispatcher: "resource://gre/modules/Messaging.sys.mjs",
+ PushCrypto: "resource://gre/modules/PushCrypto.sys.mjs",
+});
+
+// Observer notification topics for push messages and subscription status
+// changes. These are duplicated and used in `nsIPushNotifier`. They're exposed
+// on `nsIPushService` so that JS callers only need to import this service.
+const OBSERVER_TOPIC_PUSH = "push-message";
+const OBSERVER_TOPIC_SUBSCRIPTION_CHANGE = "push-subscription-change";
+const OBSERVER_TOPIC_SUBSCRIPTION_MODIFIED = "push-subscription-modified";
+
+function createSubscription({
+ scope,
+ principal,
+ browserPublicKey,
+ authSecret,
+ endpoint,
+ appServerKey,
+}) {
+ const decodedBrowserKey = ChromeUtils.base64URLDecode(browserPublicKey, {
+ padding: "ignore",
+ });
+ const decodedAuthSecret = ChromeUtils.base64URLDecode(authSecret, {
+ padding: "ignore",
+ });
+
+ return new PushSubscription({
+ endpoint,
+ scope,
+ p256dhKey: decodedBrowserKey,
+ authenticationSecret: decodedAuthSecret,
+ appServerKey,
+ });
+}
+
+function scopeWithAttrs(scope, attrs) {
+ return scope + ChromeUtils.originAttributesToSuffix(attrs);
+}
+
+export class PushService {
+ constructor() {
+ this.wrappedJSObject = this;
+ }
+
+ pushTopic = OBSERVER_TOPIC_PUSH;
+ subscriptionChangeTopic = OBSERVER_TOPIC_SUBSCRIPTION_CHANGE;
+ subscriptionModifiedTopic = OBSERVER_TOPIC_SUBSCRIPTION_MODIFIED;
+
+ // nsIObserver methods
+
+ observe(subject, topic, data) {}
+
+ // nsIPushService methods
+
+ subscribe(scope, principal, callback) {
+ this.subscribeWithKey(scope, principal, null, callback);
+ }
+
+ async subscribeWithKey(scope, principal, appServerKey, callback) {
+ const keyView = new Uint8Array(appServerKey);
+
+ if (appServerKey != null) {
+ try {
+ await lazy.PushCrypto.validateAppServerKey(keyView);
+ } catch (error) {
+ callback.onPushSubscription(Cr.NS_ERROR_DOM_PUSH_INVALID_KEY_ERR, null);
+ return;
+ }
+ }
+
+ try {
+ const response = await lazy.EventDispatcher.instance.sendRequestForResult(
+ {
+ type: "GeckoView:PushSubscribe",
+ scope: scopeWithAttrs(scope, principal.originAttributes),
+ appServerKey: appServerKey
+ ? ChromeUtils.base64URLEncode(keyView, {
+ pad: true,
+ })
+ : null,
+ }
+ );
+
+ let subscription = null;
+ if (response) {
+ subscription = createSubscription({
+ ...response,
+ scope,
+ principal,
+ appServerKey,
+ });
+ }
+
+ callback.onPushSubscription(Cr.NS_OK, subscription);
+ } catch (e) {
+ callback.onPushSubscription(Cr.NS_ERROR_FAILURE, null);
+ }
+ }
+
+ async unsubscribe(scope, principal, callback) {
+ try {
+ await lazy.EventDispatcher.instance.sendRequestForResult({
+ type: "GeckoView:PushUnsubscribe",
+ scope: scopeWithAttrs(scope, principal.originAttributes),
+ });
+
+ callback.onUnsubscribe(Cr.NS_OK, true);
+ } catch (e) {
+ callback.onUnsubscribe(Cr.NS_ERROR_FAILURE, false);
+ }
+ }
+
+ async getSubscription(scope, principal, callback) {
+ try {
+ const response = await lazy.EventDispatcher.instance.sendRequestForResult(
+ {
+ type: "GeckoView:PushGetSubscription",
+ scope: scopeWithAttrs(scope, principal.originAttributes),
+ }
+ );
+
+ let subscription = null;
+ if (response) {
+ subscription = createSubscription({
+ ...response,
+ scope,
+ principal,
+ });
+ }
+
+ callback.onPushSubscription(Cr.NS_OK, subscription);
+ } catch (e) {
+ callback.onPushSubscription(Cr.NS_ERROR_FAILURE, null);
+ }
+ }
+
+ clearForDomain(domain, callback) {
+ callback.onClear(Cr.NS_OK);
+ }
+
+ // nsIPushQuotaManager methods
+
+ notificationForOriginShown(origin) {}
+
+ notificationForOriginClosed(origin) {}
+
+ // nsIPushErrorReporter methods
+
+ reportDeliveryError(messageId, reason) {}
+}
+
+PushService.prototype.classID = Components.ID(
+ "{a54d84d7-98a4-4fec-b664-e42e512ae9cc}"
+);
+PushService.prototype.contractID = "@mozilla.org/push/Service;1";
+PushService.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIObserver",
+ "nsISupportsWeakReference",
+ "nsIPushService",
+ "nsIPushQuotaManager",
+ "nsIPushErrorReporter",
+]);
+
+/** `PushSubscription` instances are passed to all subscription callbacks. */
+class PushSubscription {
+ constructor(props) {
+ this._props = props;
+ }
+
+ /** The URL for sending messages to this subscription. */
+ get endpoint() {
+ return this._props.endpoint;
+ }
+
+ /** The last time a message was sent to this subscription. */
+ get lastPush() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ }
+
+ /** The total number of messages sent to this subscription. */
+ get pushCount() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ }
+
+ /**
+ * The app will take care of throttling, so we don't
+ * care about the quota stuff here.
+ */
+ get quota() {
+ return -1;
+ }
+
+ /**
+ * Indicates whether this subscription was created with the system principal.
+ * System subscriptions are exempt from the background message quota and
+ * permission checks.
+ */
+ get isSystemSubscription() {
+ return false;
+ }
+
+ /** The private key used to decrypt incoming push messages, in JWK format */
+ get p256dhPrivateKey() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ }
+
+ /**
+ * Indicates whether this subscription is subject to the background message
+ * quota.
+ */
+ quotaApplies() {
+ return false;
+ }
+
+ /**
+ * Indicates whether this subscription exceeded the background message quota,
+ * or the user revoked the notification permission. The caller must request a
+ * new subscription to continue receiving push messages.
+ */
+ isExpired() {
+ return false;
+ }
+
+ /**
+ * Returns a key for encrypting messages sent to this subscription. JS
+ * callers receive the key buffer as a return value, while C++ callers
+ * receive the key size and buffer as out parameters.
+ */
+ getKey(name) {
+ switch (name) {
+ case "p256dh":
+ return this._getRawKey(this._props.p256dhKey);
+
+ case "auth":
+ return this._getRawKey(this._props.authenticationSecret);
+
+ case "appServer":
+ return this._getRawKey(this._props.appServerKey);
+ }
+ return [];
+ }
+
+ _getRawKey(key) {
+ if (!key) {
+ return [];
+ }
+ return new Uint8Array(key);
+ }
+}
+
+PushSubscription.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIPushSubscription",
+]);
diff --git a/mobile/android/components/geckoview/GeckoViewStartup.sys.mjs b/mobile/android/components/geckoview/GeckoViewStartup.sys.mjs
new file mode 100644
index 0000000000..734db47887
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewStartup.sys.mjs
@@ -0,0 +1,364 @@
+/* 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/. */
+
+import { DelayedInit } from "resource://gre/modules/DelayedInit.sys.mjs";
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ ActorManagerParent: "resource://gre/modules/ActorManagerParent.sys.mjs",
+ EventDispatcher: "resource://gre/modules/Messaging.sys.mjs",
+ PdfJs: "resource://pdf.js/PdfJs.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("Startup");
+
+function InitLater(fn, object, name) {
+ return DelayedInit.schedule(fn, object, name, 15000 /* 15s max wait */);
+}
+
+const JSPROCESSACTORS = {
+ GeckoViewPermissionProcess: {
+ parent: {
+ esModuleURI:
+ "resource:///actors/GeckoViewPermissionProcessParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewPermissionProcessChild.sys.mjs",
+ observers: [
+ "getUserMedia:ask-device-permission",
+ "getUserMedia:request",
+ "recording-device-events",
+ "PeerConnection:request",
+ ],
+ },
+ },
+};
+
+const JSWINDOWACTORS = {
+ LoadURIDelegate: {
+ parent: {
+ esModuleURI: "resource:///actors/LoadURIDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/LoadURIDelegateChild.sys.mjs",
+ },
+ messageManagerGroups: ["browsers"],
+ },
+ GeckoViewPermission: {
+ parent: {
+ esModuleURI: "resource:///actors/GeckoViewPermissionParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewPermissionChild.sys.mjs",
+ },
+ allFrames: true,
+ includeChrome: true,
+ },
+ GeckoViewPrompt: {
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewPromptChild.sys.mjs",
+ events: {
+ click: { capture: false, mozSystemGroup: true },
+ contextmenu: { capture: false, mozSystemGroup: true },
+ mozshowdropdown: {},
+ "mozshowdropdown-sourcetouch": {},
+ MozOpenDateTimePicker: {},
+ DOMPopupBlocked: { capture: false, mozSystemGroup: true },
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ GeckoViewFormValidation: {
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewFormValidationChild.sys.mjs",
+ events: {
+ MozInvalidForm: {},
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ GeckoViewPdfjs: {
+ parent: {
+ esModuleURI: "resource://pdf.js/GeckoViewPdfjsParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource://pdf.js/GeckoViewPdfjsChild.sys.mjs",
+ },
+ allFrames: true,
+ },
+};
+
+export class GeckoViewStartup {
+ /* ---------- nsIObserver ---------- */
+ observe(aSubject, aTopic, aData) {
+ debug`observe: ${aTopic}`;
+ switch (aTopic) {
+ case "content-process-ready-for-script":
+ case "app-startup": {
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewConsole", {
+ module: "resource://gre/modules/GeckoViewConsole.sys.mjs",
+ });
+
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewStorageController", {
+ module: "resource://gre/modules/GeckoViewStorageController.sys.mjs",
+ ged: [
+ "GeckoView:ClearData",
+ "GeckoView:ClearSessionContextData",
+ "GeckoView:ClearHostData",
+ "GeckoView:ClearBaseDomainData",
+ "GeckoView:GetAllPermissions",
+ "GeckoView:GetPermissionsByURI",
+ "GeckoView:SetPermission",
+ "GeckoView:SetPermissionByURI",
+ "GeckoView:GetCookieBannerModeForDomain",
+ "GeckoView:SetCookieBannerModeForDomain",
+ "GeckoView:RemoveCookieBannerModeForDomain",
+ ],
+ });
+
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewPushController", {
+ module: "resource://gre/modules/GeckoViewPushController.sys.mjs",
+ ged: ["GeckoView:PushEvent", "GeckoView:PushSubscriptionChanged"],
+ });
+
+ GeckoViewUtils.addLazyPrefObserver(
+ {
+ name: "geckoview.console.enabled",
+ default: false,
+ },
+ {
+ handler: _ => this.GeckoViewConsole,
+ }
+ );
+
+ // Parent process only
+ if (
+ Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_DEFAULT
+ ) {
+ lazy.ActorManagerParent.addJSWindowActors(JSWINDOWACTORS);
+ lazy.ActorManagerParent.addJSProcessActors(JSPROCESSACTORS);
+
+ if (Services.appinfo.sessionHistoryInParent) {
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewSessionStore", {
+ module: "resource://gre/modules/GeckoViewSessionStore.sys.mjs",
+ observers: [
+ "browsing-context-did-set-embedder",
+ "browsing-context-discarded",
+ ],
+ });
+ }
+
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewWebExtension", {
+ module: "resource://gre/modules/GeckoViewWebExtension.sys.mjs",
+ ged: [
+ "GeckoView:ActionDelegate:Attached",
+ "GeckoView:BrowserAction:Click",
+ "GeckoView:PageAction:Click",
+ "GeckoView:RegisterWebExtension",
+ "GeckoView:UnregisterWebExtension",
+ "GeckoView:WebExtension:CancelInstall",
+ "GeckoView:WebExtension:Disable",
+ "GeckoView:WebExtension:Enable",
+ "GeckoView:WebExtension:EnsureBuiltIn",
+ "GeckoView:WebExtension:Get",
+ "GeckoView:WebExtension:Install",
+ "GeckoView:WebExtension:InstallBuiltIn",
+ "GeckoView:WebExtension:List",
+ "GeckoView:WebExtension:PortDisconnect",
+ "GeckoView:WebExtension:PortMessageFromApp",
+ "GeckoView:WebExtension:SetPBAllowed",
+ "GeckoView:WebExtension:Uninstall",
+ "GeckoView:WebExtension:Update",
+ "GeckoView:WebExtension:EnableProcessSpawning",
+ "GeckoView:WebExtension:DisableProcessSpawning",
+ ],
+ observers: [
+ "devtools-installed-addon",
+ "testing-installed-addon",
+ "testing-uninstalled-addon",
+ ],
+ });
+
+ GeckoViewUtils.addLazyGetter(this, "ChildCrashHandler", {
+ module: "resource://gre/modules/ChildCrashHandler.sys.mjs",
+ observers: [
+ "compositor:process-aborted",
+ "ipc:content-created",
+ "ipc:content-shutdown",
+ "process-type-set",
+ ],
+ });
+
+ lazy.EventDispatcher.instance.registerListener(this, [
+ "GeckoView:StorageDelegate:Attached",
+ ]);
+ }
+
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewTranslationsSettings", {
+ module: "resource://gre/modules/GeckoViewTranslations.sys.mjs",
+ ged: [
+ "GeckoView:Translations:IsTranslationEngineSupported",
+ "GeckoView:Translations:PreferredLanguages",
+ "GeckoView:Translations:ManageModel",
+ "GeckoView:Translations:TranslationInformation",
+ "GeckoView:Translations:ModelInformation",
+ "GeckoView:Translations:GetLanguageSetting",
+ "GeckoView:Translations:GetLanguageSettings",
+ "GeckoView:Translations:SetLanguageSettings",
+ "GeckoView:Translations:GetNeverTranslateSpecifiedSites",
+ "GeckoView:Translations:SetNeverTranslateSpecifiedSite",
+ "GeckoView:Translations:GetTranslateDownloadSize",
+ ],
+ });
+
+ break;
+ }
+
+ case "profile-after-change": {
+ GeckoViewUtils.addLazyGetter(this, "GeckoViewRemoteDebugger", {
+ module: "resource://gre/modules/GeckoViewRemoteDebugger.sys.mjs",
+ init: gvrd => gvrd.onInit(),
+ });
+
+ GeckoViewUtils.addLazyPrefObserver(
+ {
+ name: "devtools.debugger.remote-enabled",
+ default: false,
+ },
+ {
+ handler: _ => this.GeckoViewRemoteDebugger,
+ }
+ );
+
+ GeckoViewUtils.addLazyGetter(this, "DownloadTracker", {
+ module: "resource://gre/modules/GeckoViewWebExtension.sys.mjs",
+ ged: ["GeckoView:WebExtension:DownloadChanged"],
+ });
+
+ ChromeUtils.importESModule(
+ "resource://gre/modules/NotificationDB.sys.mjs"
+ );
+
+ // Listen for global EventDispatcher messages
+ lazy.EventDispatcher.instance.registerListener(this, [
+ "GeckoView:ResetUserPrefs",
+ "GeckoView:SetDefaultPrefs",
+ "GeckoView:SetLocale",
+ "GeckoView:InitialForeground",
+ ]);
+
+ Services.obs.addObserver(this, "browser-idle-startup-tasks-finished");
+ Services.obs.addObserver(this, "handlersvc-store-initialized");
+
+ Services.obs.notifyObservers(null, "geckoview-startup-complete");
+ break;
+ }
+ case "browser-idle-startup-tasks-finished": {
+ // TODO bug 1730026: when an alternative is introduced that runs once,
+ // replace this observer topic with that alternative.
+ // This only needs to happen once during startup.
+ Services.obs.removeObserver(this, aTopic);
+ // Notify the start up crash tracker that the browser has successfully
+ // started up so the startup cache isn't rebuilt on next startup.
+ Services.startup.trackStartupCrashEnd();
+ break;
+ }
+ case "handlersvc-store-initialized": {
+ // Initialize PdfJs when running in-process and remote. This only
+ // happens once since PdfJs registers global hooks. If the PdfJs
+ // extension is installed the init method below will be overridden
+ // leaving initialization to the extension.
+ // parent only: configure default prefs, set up pref observers, register
+ // pdf content handler, and initializes parent side message manager
+ // shim for privileged api access.
+ try {
+ lazy.PdfJs.init(this._isNewProfile);
+ } catch {}
+ break;
+ }
+ }
+ }
+
+ onEvent(aEvent, aData, aCallback) {
+ debug`onEvent ${aEvent}`;
+
+ switch (aEvent) {
+ case "GeckoView:InitialForeground": {
+ // ExtensionProcessCrashObserver observes this topic to determine when
+ // the app goes into the foreground for the first time. This could be useful
+ // when the app is initially created in the background because, in this case,
+ // the "application-foreground" topic isn't notified when the application is
+ // moved into the foreground later. That is because "application-foreground"
+ // is only going to be notified when the application was first paused.
+ Services.obs.notifyObservers(null, "geckoview-initial-foreground");
+ break;
+ }
+ case "GeckoView:ResetUserPrefs": {
+ for (const name of aData.names) {
+ Services.prefs.clearUserPref(name);
+ }
+ break;
+ }
+ case "GeckoView:SetDefaultPrefs": {
+ const prefs = Services.prefs.getDefaultBranch("");
+ for (const [name, value] of Object.entries(aData)) {
+ try {
+ switch (typeof value) {
+ case "string":
+ prefs.setStringPref(name, value);
+ break;
+ case "number":
+ prefs.setIntPref(name, value);
+ break;
+ case "boolean":
+ prefs.setBoolPref(name, value);
+ break;
+ default:
+ throw new Error(
+ `Can't set ${name} to ${value}. Type ${typeof value} is not supported.`
+ );
+ }
+ } catch (e) {
+ warn`Failed to set preference ${name}: ${e}`;
+ }
+ }
+ break;
+ }
+ case "GeckoView:SetLocale":
+ if (aData.requestedLocales) {
+ Services.locale.requestedLocales = aData.requestedLocales;
+ }
+ const pls = Cc["@mozilla.org/pref-localizedstring;1"].createInstance(
+ Ci.nsIPrefLocalizedString
+ );
+ pls.data = aData.acceptLanguages;
+ Services.prefs.setComplexValue(
+ "intl.accept_languages",
+ Ci.nsIPrefLocalizedString,
+ pls
+ );
+ break;
+
+ case "GeckoView:StorageDelegate:Attached":
+ InitLater(() => {
+ const loginDetection = Cc[
+ "@mozilla.org/login-detection-service;1"
+ ].createInstance(Ci.nsILoginDetectionService);
+ loginDetection.init();
+ });
+ break;
+ }
+ }
+}
+
+GeckoViewStartup.prototype.classID = Components.ID(
+ "{8e993c34-fdd6-432c-967e-f995d888777f}"
+);
+GeckoViewStartup.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIObserver",
+]);
diff --git a/mobile/android/components/geckoview/GeckoViewStreamListener.cpp b/mobile/android/components/geckoview/GeckoViewStreamListener.cpp
new file mode 100644
index 0000000000..71b9fadeb5
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewStreamListener.cpp
@@ -0,0 +1,298 @@
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil; -*-
+ * 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 "GeckoViewStreamListener.h"
+
+#include "mozilla/fallible.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsIChannelEventSink.h"
+#include "nsIHttpChannel.h"
+#include "nsIHttpHeaderVisitor.h"
+#include "nsIInputStream.h"
+#include "nsINSSErrorsService.h"
+#include "nsITransportSecurityInfo.h"
+#include "nsIWebProgressListener.h"
+#include "nsIX509Cert.h"
+#include "nsPrintfCString.h"
+
+#include "nsNetUtil.h"
+
+#include "JavaBuiltins.h"
+
+using namespace mozilla;
+
+NS_IMPL_ISUPPORTS(GeckoViewStreamListener, nsIStreamListener,
+ nsIInterfaceRequestor, nsIChannelEventSink)
+
+class HeaderVisitor final : public nsIHttpHeaderVisitor {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+ explicit HeaderVisitor(java::WebResponse::Builder::Param aBuilder)
+ : mBuilder(aBuilder) {}
+
+ NS_IMETHOD
+ VisitHeader(const nsACString& aHeader, const nsACString& aValue) override {
+ mBuilder->Header(aHeader, aValue);
+ return NS_OK;
+ }
+
+ private:
+ virtual ~HeaderVisitor() {}
+
+ const java::WebResponse::Builder::GlobalRef mBuilder;
+};
+
+NS_IMPL_ISUPPORTS(HeaderVisitor, nsIHttpHeaderVisitor)
+
+class StreamSupport final
+ : public java::GeckoInputStream::Support::Natives<StreamSupport> {
+ public:
+ typedef java::GeckoInputStream::Support::Natives<StreamSupport> Base;
+ using Base::AttachNative;
+ using Base::GetNative;
+
+ explicit StreamSupport(java::GeckoInputStream::Support::Param aInstance,
+ nsIRequest* aRequest)
+ : mInstance(aInstance), mRequest(aRequest) {}
+
+ void Close() {
+ mRequest->Cancel(NS_ERROR_ABORT);
+ mRequest->Resume();
+
+ // This is basically `delete this`, so don't run anything else!
+ Base::DisposeNative(mInstance);
+ }
+
+ void Resume() { mRequest->Resume(); }
+
+ private:
+ java::GeckoInputStream::Support::GlobalRef mInstance;
+ nsCOMPtr<nsIRequest> mRequest;
+};
+
+NS_IMETHODIMP
+GeckoViewStreamListener::OnStartRequest(nsIRequest* aRequest) {
+ MOZ_ASSERT(!mStream);
+
+ nsresult status;
+ aRequest->GetStatus(&status);
+ if (NS_FAILED(status)) {
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+ CompleteWithError(status, channel);
+ return NS_OK;
+ }
+
+ // We're expecting data later via OnDataAvailable, so create the stream now.
+ InitializeStreamSupport(aRequest);
+
+ mStream = java::GeckoInputStream::New(mSupport);
+
+ // Suspend the request immediately. It will be resumed when (if) someone
+ // tries to read the Java stream.
+ aRequest->Suspend();
+
+ nsresult rv = HandleWebResponse(aRequest);
+ if (NS_FAILED(rv)) {
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+ CompleteWithError(rv, channel);
+ return NS_OK;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+GeckoViewStreamListener::OnStopRequest(nsIRequest* aRequest,
+ nsresult aStatusCode) {
+ if (mStream) {
+ if (NS_FAILED(aStatusCode)) {
+ mStream->SendError();
+ } else {
+ mStream->SendEof();
+ }
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP GeckoViewStreamListener::OnDataAvailable(
+ nsIRequest* aRequest, nsIInputStream* aInputStream, uint64_t aOffset,
+ uint32_t aCount) {
+ MOZ_ASSERT(mStream);
+
+ // We only need this for the ReadSegments call, the value is unused.
+ uint32_t countRead;
+ nsresult rv =
+ aInputStream->ReadSegments(WriteSegment, this, aCount, &countRead);
+ NS_ENSURE_SUCCESS(rv, rv);
+ return rv;
+}
+
+NS_IMETHODIMP
+GeckoViewStreamListener::GetInterface(const nsIID& aIID, void** aResultOut) {
+ if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
+ *aResultOut = static_cast<nsIChannelEventSink*>(this);
+ NS_ADDREF_THIS();
+ return NS_OK;
+ }
+
+ return NS_ERROR_NO_INTERFACE;
+}
+
+NS_IMETHODIMP
+GeckoViewStreamListener::AsyncOnChannelRedirect(
+ nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t flags,
+ nsIAsyncVerifyRedirectCallback* callback) {
+ callback->OnRedirectVerifyCallback(NS_OK);
+ return NS_OK;
+}
+
+/* static */
+nsresult GeckoViewStreamListener::WriteSegment(
+ nsIInputStream* aInputStream, void* aClosure, const char* aFromSegment,
+ uint32_t aToOffset, uint32_t aCount, uint32_t* aWriteCount) {
+ GeckoViewStreamListener* self =
+ static_cast<GeckoViewStreamListener*>(aClosure);
+ MOZ_ASSERT(self);
+ MOZ_ASSERT(self->mStream);
+
+ *aWriteCount = aCount;
+
+ jni::ByteArray::LocalRef buffer = jni::ByteArray::New(
+ reinterpret_cast<signed char*>(const_cast<char*>(aFromSegment)),
+ *aWriteCount, fallible);
+ if (!buffer) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (NS_FAILED(self->mStream->AppendBuffer(buffer))) {
+ // The stream was closed or something, abort reading this channel.
+ return NS_ERROR_ABORT;
+ }
+
+ return NS_OK;
+}
+
+nsresult GeckoViewStreamListener::HandleWebResponse(nsIRequest* aRequest) {
+ nsresult rv;
+
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // URI
+ nsCOMPtr<nsIURI> uri;
+ rv = channel->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoCString uriSpec;
+ rv = uri->GetSpec(uriSpec);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ java::WebResponse::Builder::LocalRef builder =
+ java::WebResponse::Builder::New(uriSpec);
+
+ // Body stream
+ if (mStream) {
+ builder->Body(mStream);
+ }
+
+ // Redirected
+ nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
+ builder->Redirected(!loadInfo->RedirectChain().IsEmpty());
+
+ // Secure status
+ auto [certBytes, isSecure] = CertificateFromChannel(channel);
+ builder->IsSecure(isSecure);
+ if (certBytes) {
+ rv = builder->CertificateBytes(certBytes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ // We might need some additional info for response to http/https request
+ nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel, &rv));
+ if (httpChannel) {
+ // Status code
+ uint32_t statusCode;
+ rv = httpChannel->GetResponseStatus(&statusCode);
+ NS_ENSURE_SUCCESS(rv, rv);
+ builder->StatusCode(statusCode);
+
+ // Headers
+ RefPtr<HeaderVisitor> visitor = new HeaderVisitor(builder);
+ rv = httpChannel->VisitResponseHeaders(visitor);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ // Headers for other responses
+ // try to provide some basic metadata about the response
+ nsString filename;
+ if (NS_SUCCEEDED(channel->GetContentDispositionFilename(filename))) {
+ builder->Header(jni::StringParam(u"content-disposition"_ns),
+ nsPrintfCString("attachment; filename=\"%s\"",
+ NS_ConvertUTF16toUTF8(filename).get()));
+ }
+
+ nsCString contentType;
+ if (NS_SUCCEEDED(channel->GetContentType(contentType))) {
+ builder->Header(jni::StringParam(u"content-type"_ns), contentType);
+ }
+
+ int64_t contentLength = 0;
+ if (NS_SUCCEEDED(channel->GetContentLength(&contentLength))) {
+ nsString contentLengthString;
+ contentLengthString.AppendInt(contentLength);
+ builder->Header(jni::StringParam(u"content-length"_ns),
+ contentLengthString);
+ }
+ }
+
+ java::WebResponse::GlobalRef response = builder->Build();
+
+ SendWebResponse(response);
+ return NS_OK;
+}
+
+void GeckoViewStreamListener::InitializeStreamSupport(nsIRequest* aRequest) {
+ StreamSupport::Init();
+
+ mSupport = java::GeckoInputStream::Support::New();
+ StreamSupport::AttachNative(
+ mSupport, mozilla::MakeUnique<StreamSupport>(mSupport, aRequest));
+}
+
+std::tuple<jni::ByteArray::LocalRef, java::sdk::Boolean::LocalRef>
+GeckoViewStreamListener::CertificateFromChannel(nsIChannel* aChannel) {
+ MOZ_ASSERT(aChannel);
+
+ nsCOMPtr<nsITransportSecurityInfo> securityInfo;
+ aChannel->GetSecurityInfo(getter_AddRefs(securityInfo));
+ if (!securityInfo) {
+ return std::make_tuple((jni::ByteArray::LocalRef) nullptr,
+ (java::sdk::Boolean::LocalRef) nullptr);
+ }
+
+ uint32_t securityState = 0;
+ securityInfo->GetSecurityState(&securityState);
+ auto isSecure = securityState == nsIWebProgressListener::STATE_IS_SECURE
+ ? java::sdk::Boolean::TRUE()
+ : java::sdk::Boolean::FALSE();
+
+ nsCOMPtr<nsIX509Cert> cert;
+ securityInfo->GetServerCert(getter_AddRefs(cert));
+ if (!cert) {
+ return std::make_tuple((jni::ByteArray::LocalRef) nullptr,
+ (java::sdk::Boolean::LocalRef) nullptr);
+ }
+
+ nsTArray<uint8_t> derBytes;
+ nsresult rv = cert->GetRawDER(derBytes);
+ NS_ENSURE_SUCCESS(rv,
+ std::make_tuple((jni::ByteArray::LocalRef) nullptr,
+ (java::sdk::Boolean::LocalRef) nullptr));
+
+ auto certBytes = jni::ByteArray::New(
+ reinterpret_cast<const int8_t*>(derBytes.Elements()), derBytes.Length());
+
+ return std::make_tuple(certBytes, isSecure);
+}
diff --git a/mobile/android/components/geckoview/GeckoViewStreamListener.h b/mobile/android/components/geckoview/GeckoViewStreamListener.h
new file mode 100644
index 0000000000..b42249f458
--- /dev/null
+++ b/mobile/android/components/geckoview/GeckoViewStreamListener.h
@@ -0,0 +1,57 @@
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil; -*-
+ * 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 GeckoViewStreamListener_h__
+#define GeckoViewStreamListener_h__
+
+#include "nsIStreamListener.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIChannelEventSink.h"
+
+#include "mozilla/widget/EventDispatcher.h"
+#include "mozilla/java/GeckoInputStreamNatives.h"
+#include "mozilla/java/WebResponseWrappers.h"
+
+#include "JavaBuiltins.h"
+
+namespace mozilla {
+
+class GeckoViewStreamListener : public nsIStreamListener,
+ public nsIInterfaceRequestor,
+ public nsIChannelEventSink {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIREQUESTOBSERVER
+ NS_DECL_NSISTREAMLISTENER
+ NS_DECL_NSIINTERFACEREQUESTOR
+ NS_DECL_NSICHANNELEVENTSINK
+
+ explicit GeckoViewStreamListener() {}
+
+ static std::tuple<jni::ByteArray::LocalRef, java::sdk::Boolean::LocalRef>
+ CertificateFromChannel(nsIChannel* aChannel);
+
+ protected:
+ virtual ~GeckoViewStreamListener() {}
+
+ java::GeckoInputStream::GlobalRef mStream;
+ java::GeckoInputStream::Support::GlobalRef mSupport;
+
+ void InitializeStreamSupport(nsIRequest* aRequest);
+
+ static nsresult WriteSegment(nsIInputStream* aInputStream, void* aClosure,
+ const char* aFromSegment, uint32_t aToOffset,
+ uint32_t aCount, uint32_t* aWriteCount);
+
+ virtual nsresult HandleWebResponse(nsIRequest* aRequest);
+
+ virtual void SendWebResponse(java::WebResponse::Param aResponse) = 0;
+
+ virtual void CompleteWithError(nsresult aStatus, nsIChannel* aChannel) = 0;
+};
+
+} // namespace mozilla
+
+#endif // GeckoViewStreamListener_h__
diff --git a/mobile/android/components/geckoview/LoginStorageDelegate.sys.mjs b/mobile/android/components/geckoview/LoginStorageDelegate.sys.mjs
new file mode 100644
index 0000000000..28916917ca
--- /dev/null
+++ b/mobile/android/components/geckoview/LoginStorageDelegate.sys.mjs
@@ -0,0 +1,126 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ GeckoViewAutocomplete: "resource://gre/modules/GeckoViewAutocomplete.sys.mjs",
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+ LoginEntry: "resource://gre/modules/GeckoViewAutocomplete.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("LoginStorageDelegate");
+
+// Sync with LoginSaveOption.Hint in Autocomplete.java.
+const LoginStorageHint = {
+ NONE: 0,
+ GENERATED: 1 << 0,
+ LOW_CONFIDENCE: 1 << 1,
+};
+
+export class LoginStorageDelegate {
+ _createMessage({ dismissed, autoSavedLoginGuid }, aLogins) {
+ let hint = LoginStorageHint.NONE;
+ if (dismissed) {
+ hint |= LoginStorageHint.LOW_CONFIDENCE;
+ }
+ if (autoSavedLoginGuid) {
+ hint |= LoginStorageHint.GENERATED;
+ }
+ return {
+ // Sync with PromptController
+ type: "Autocomplete:Save:Login",
+ hint,
+ logins: aLogins,
+ };
+ }
+
+ promptToSavePassword(
+ aBrowser,
+ aLogin,
+ dismissed = false,
+ notifySaved = false
+ ) {
+ const prompt = new lazy.GeckoViewPrompter(aBrowser.ownerGlobal);
+ prompt.asyncShowPrompt(
+ this._createMessage({ dismissed }, [
+ lazy.LoginEntry.fromLoginInfo(aLogin),
+ ]),
+ result => {
+ const selectedLogin = result?.selection?.value;
+
+ if (!selectedLogin) {
+ return;
+ }
+
+ const loginInfo = lazy.LoginEntry.parse(selectedLogin).toLoginInfo();
+ Services.obs.notifyObservers(loginInfo, "passwordmgr-prompt-save");
+
+ lazy.GeckoViewAutocomplete.onLoginSave(selectedLogin);
+ }
+ );
+
+ return {
+ dismiss() {
+ prompt.dismiss();
+ },
+ };
+ }
+
+ promptToChangePassword(
+ aBrowser,
+ aOldLogin,
+ aNewLogin,
+ dismissed = false,
+ notifySaved = false,
+ autoSavedLoginGuid = ""
+ ) {
+ const newLogin = lazy.LoginEntry.fromLoginInfo(aOldLogin || aNewLogin);
+ const oldGuid = (aOldLogin && newLogin.guid) || null;
+ newLogin.origin = aNewLogin.origin;
+ newLogin.formActionOrigin = aNewLogin.formActionOrigin;
+ newLogin.password = aNewLogin.password;
+ newLogin.username = aNewLogin.username;
+
+ const prompt = new lazy.GeckoViewPrompter(aBrowser.ownerGlobal);
+ prompt.asyncShowPrompt(
+ this._createMessage({ dismissed, autoSavedLoginGuid }, [newLogin]),
+ result => {
+ const selectedLogin = result?.selection?.value;
+
+ if (!selectedLogin) {
+ return;
+ }
+
+ lazy.GeckoViewAutocomplete.onLoginSave(selectedLogin);
+
+ const loginInfo = lazy.LoginEntry.parse(selectedLogin).toLoginInfo();
+ Services.obs.notifyObservers(
+ loginInfo,
+ "passwordmgr-prompt-change",
+ oldGuid
+ );
+ }
+ );
+
+ return {
+ dismiss() {
+ prompt.dismiss();
+ },
+ };
+ }
+
+ promptToChangePasswordWithUsernames(aBrowser, aLogins, aNewLogin) {
+ this.promptToChangePassword(aBrowser, null /* oldLogin */, aNewLogin);
+ }
+}
+
+LoginStorageDelegate.prototype.classID = Components.ID(
+ "{3d765750-1c3d-11ea-aaef-0800200c9a66}"
+);
+LoginStorageDelegate.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsILoginManagerPrompter",
+]);
diff --git a/mobile/android/components/geckoview/PromptCollection.sys.mjs b/mobile/android/components/geckoview/PromptCollection.sys.mjs
new file mode 100644
index 0000000000..472dea3316
--- /dev/null
+++ b/mobile/android/components/geckoview/PromptCollection.sys.mjs
@@ -0,0 +1,43 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+});
+
+const { debug, warn } = GeckoViewUtils.initLogging("PromptCollection");
+
+export class PromptCollection {
+ confirmRepost(browsingContext) {
+ const msg = {
+ type: "repost",
+ };
+ const prompter = new lazy.GeckoViewPrompter(browsingContext);
+ const result = prompter.showPrompt(msg);
+ return !!result?.allow;
+ }
+
+ asyncBeforeUnloadCheck(browsingContext) {
+ return new Promise(resolve => {
+ const msg = {
+ type: "beforeUnload",
+ };
+ const prompter = new lazy.GeckoViewPrompter(browsingContext);
+ prompter.asyncShowPrompt(msg, resolve);
+ }).then(result => !!result?.allow);
+ }
+
+ confirmFolderUpload() {
+ // Folder upload is not supported by GeckoView yet, see Bug 1674428.
+ return false;
+ }
+}
+
+PromptCollection.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIPromptCollection",
+]);
diff --git a/mobile/android/components/geckoview/ShareDelegate.sys.mjs b/mobile/android/components/geckoview/ShareDelegate.sys.mjs
new file mode 100644
index 0000000000..986d2b85d5
--- /dev/null
+++ b/mobile/android/components/geckoview/ShareDelegate.sys.mjs
@@ -0,0 +1,77 @@
+/* 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/. */
+
+import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ GeckoViewPrompter: "resource://gre/modules/GeckoViewPrompter.sys.mjs",
+});
+
+const domBundle = Services.strings.createBundle(
+ "chrome://global/locale/dom/dom.properties"
+);
+
+const { debug, warn } = GeckoViewUtils.initLogging("ShareDelegate");
+
+export class ShareDelegate {
+ init(aParent) {
+ this._openerWindow = aParent;
+ }
+
+ get openerWindow() {
+ return this._openerWindow;
+ }
+
+ async share(aTitle, aText, aUri) {
+ const ABORT = 2;
+ const FAILURE = 1;
+ const SUCCESS = 0;
+
+ const msg = {
+ type: "share",
+ title: aTitle,
+ text: aText,
+ uri: aUri ? aUri.displaySpec : null,
+ };
+ const prompt = new lazy.GeckoViewPrompter(this._openerWindow);
+ const result = await new Promise(resolve => {
+ prompt.asyncShowPrompt(msg, resolve);
+ });
+
+ if (!result) {
+ // A null result is treated as a dismissal in GeckoViewPrompter.
+ throw new DOMException(
+ domBundle.GetStringFromName("WebShareAPI_Aborted"),
+ "AbortError"
+ );
+ }
+
+ const res = result && result.response;
+ switch (res) {
+ case FAILURE:
+ throw new DOMException(
+ domBundle.GetStringFromName("WebShareAPI_Failed"),
+ "DataError"
+ );
+ case ABORT: // Handle aborted attempt and invalid responses the same.
+ throw new DOMException(
+ domBundle.GetStringFromName("WebShareAPI_Aborted"),
+ "AbortError"
+ );
+ case SUCCESS:
+ return;
+ default:
+ throw new DOMException("Unknown error.", "UnknownError");
+ }
+ }
+}
+
+ShareDelegate.prototype.classID = Components.ID(
+ "{1201d357-8417-4926-a694-e6408fbedcf8}"
+);
+ShareDelegate.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsISharePicker",
+]);
diff --git a/mobile/android/components/geckoview/components.conf b/mobile/android/components/geckoview/components.conf
new file mode 100644
index 0000000000..ea9b9eba09
--- /dev/null
+++ b/mobile/android/components/geckoview/components.conf
@@ -0,0 +1,107 @@
+# -*- 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/.
+
+Classes = [
+ {
+ 'cid': '{3e30d2a0-9934-11ea-bb37-0242ac130002}',
+ 'contract_ids': ['@mozilla.org/embedcomp/prompt-collection;1'],
+ 'esModule': 'resource://gre/modules/PromptCollection.sys.mjs',
+ 'constructor': 'PromptCollection',
+ },
+ {
+ 'js_name': 'prompt',
+ 'cid': '{076ac188-23c1-4390-aa08-7ef1f78ca5d9}',
+ 'contract_ids': [
+ '@mozilla.org/prompter;1',
+ ],
+ 'interfaces': ['nsIPromptService'],
+ 'esModule': 'resource://gre/modules/GeckoViewPrompt.sys.mjs',
+ 'constructor': 'PromptFactory',
+ },
+ {
+ 'cid': '{8e993c34-fdd6-432c-967e-f995d888777f}',
+ 'contract_ids': ['@mozilla.org/geckoview/startup;1'],
+ 'esModule': 'resource://gre/modules/GeckoViewStartup.sys.mjs',
+ 'constructor': 'GeckoViewStartup',
+ },
+ {
+ 'cid': '{42f3c238-e8e8-4015-9ca2-148723a8afcf}',
+ 'contract_ids': ['@mozilla.org/content-permission/prompt;1'],
+ 'esModule': 'resource://gre/modules/GeckoViewPermission.sys.mjs',
+ 'constructor': 'GeckoViewPermission',
+ },
+ {
+ 'cid': '{a54d84d7-98a4-4fec-b664-e42e512ae9cc}',
+ 'contract_ids': ['@mozilla.org/push/Service;1'],
+ 'esModule': 'resource://gre/modules/GeckoViewPush.sys.mjs',
+ 'constructor': 'PushService',
+ },
+ {
+ 'cid': '{fc4bec74-ddd0-4ea8-9a66-9a5081258e32}',
+ 'contract_ids': ['@mozilla.org/parent/colorpicker;1'],
+ 'esModule': 'resource://gre/modules/ColorPickerDelegate.sys.mjs',
+ 'constructor': 'ColorPickerDelegate',
+ 'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+ },
+ {
+ 'cid': '{25fdbae6-f684-4bf0-b773-ff2b7a6273c8}',
+ 'contract_ids': ['@mozilla.org/parent/filepicker;1'],
+ 'esModule': 'resource://gre/modules/FilePickerDelegate.sys.mjs',
+ 'constructor': 'FilePickerDelegate',
+ 'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+ },
+ {
+ 'cid': '{1201d357-8417-4926-a694-e6408fbedcf8}',
+ 'contract_ids': ['@mozilla.org/sharepicker;1'],
+ 'esModule': 'resource://gre/modules/ShareDelegate.sys.mjs',
+ 'constructor': 'ShareDelegate',
+ 'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+ },
+ {
+ 'cid': '{3d765750-1c3d-11ea-aaef-0800200c9a66}',
+ 'contract_ids': ['@mozilla.org/login-manager/prompter;1'],
+ 'esModule': 'resource://gre/modules/LoginStorageDelegate.sys.mjs',
+ 'constructor': 'LoginStorageDelegate',
+ 'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+ },
+ {
+ 'cid': '{91455c77-64a1-4c37-be00-f94eb9c7b8e1}',
+ 'contract_ids': [
+ '@mozilla.org/uriloader/external-helper-app-service;1',
+ ],
+ 'type': 'GeckoViewExternalAppService',
+ 'constructor': 'GeckoViewExternalAppService::GetSingleton',
+ 'headers': ['GeckoViewExternalAppService.h'],
+ 'processes': ProcessSelector.ALLOW_IN_SOCKET_PROCESS,
+ },
+ {
+ 'cid': '{a8f4582e-4b47-4e06-970d-b94b76977bf7}',
+ 'contract_ids': ['@mozilla.org/network/protocol;1?name=content'],
+ 'type': 'GeckoViewContentProtocolHandler',
+ 'headers': ['./GeckoViewContentProtocolHandler.h'],
+ 'protocol_config': {
+ 'scheme': 'content',
+ 'flags': [
+ 'URI_IS_POTENTIALLY_TRUSTWORTHY',
+ 'URI_IS_LOCAL_RESOURCE',
+ 'URI_DANGEROUS_TO_LOAD',
+ ],
+ },
+ },
+]
+
+if defined('MOZ_ANDROID_HISTORY'):
+ Classes += [
+ {
+ 'name': 'History',
+ 'cid': '{0937a705-91a6-417a-8292-b22eb10da86c}',
+ 'contract_ids': ['@mozilla.org/browser/history;1'],
+ 'singleton': True,
+ 'type': 'GeckoViewHistory',
+ 'headers': ['GeckoViewHistory.h'],
+ 'constructor': 'GeckoViewHistory::GetSingleton',
+ },
+ ]
diff --git a/mobile/android/components/geckoview/moz.build b/mobile/android/components/geckoview/moz.build
new file mode 100644
index 0000000000..7b115ed03b
--- /dev/null
+++ b/mobile/android/components/geckoview/moz.build
@@ -0,0 +1,55 @@
+# -*- 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/.
+
+SOURCES += [
+ "GeckoViewContentChannel.cpp",
+ "GeckoViewContentProtocolHandler.cpp",
+ "GeckoViewExternalAppService.cpp",
+ "GeckoViewInputStream.cpp",
+ "GeckoViewOutputStream.cpp",
+ "GeckoViewStreamListener.cpp",
+]
+
+EXPORTS += [
+ "GeckoViewContentChannel.h",
+ "GeckoViewContentProtocolHandler.h",
+ "GeckoViewExternalAppService.h",
+ "GeckoViewInputStream.h",
+ "GeckoViewOutputStream.h",
+ "GeckoViewStreamListener.h",
+]
+
+if CONFIG["MOZ_ANDROID_HISTORY"]:
+ EXPORTS += [
+ "GeckoViewHistory.h",
+ ]
+ SOURCES += [
+ "GeckoViewHistory.cpp",
+ ]
+ include("/ipc/chromium/chromium-config.mozbuild")
+
+XPCOM_MANIFESTS += [
+ "components.conf",
+]
+
+EXTRA_COMPONENTS += [
+ "GeckoView.manifest",
+]
+
+EXTRA_JS_MODULES += [
+ "ColorPickerDelegate.sys.mjs",
+ "FilePickerDelegate.sys.mjs",
+ "GeckoViewPermission.sys.mjs",
+ "GeckoViewPrompt.sys.mjs",
+ "GeckoViewPrompter.sys.mjs",
+ "GeckoViewPush.sys.mjs",
+ "GeckoViewStartup.sys.mjs",
+ "LoginStorageDelegate.sys.mjs",
+ "PromptCollection.sys.mjs",
+ "ShareDelegate.sys.mjs",
+]
+
+FINAL_LIBRARY = "xul"