gecko-dev/toolkit/actors/WebNavigationChild.jsm

/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
"use strict";

var EXPORTED_SYMBOLS = ["WebNavigationChild"];

const {ActorChild} = ChromeUtils.import("resource://gre/modules/ActorChild.jsm");
const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
const {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");

ChromeUtils.defineModuleGetter(this, "AppConstants",
                               "resource://gre/modules/AppConstants.jsm");
ChromeUtils.defineModuleGetter(this, "E10SUtils",
                               "resource://gre/modules/E10SUtils.jsm");

XPCOMUtils.defineLazyServiceGetter(this, "CrashReporter",
                                   "@mozilla.org/xre/app-info;1",
                                   "nsICrashReporter");

class WebNavigationChild extends ActorChild {
  get webNavigation() {
    return this.mm.docShell.QueryInterface(Ci.nsIWebNavigation);
  }

  receiveMessage(message) {
    switch (message.name) {
      case "WebNavigation:GoBack":
        this.goBack(message.data);
        break;
      case "WebNavigation:GoForward":
        this.goForward(message.data);
        break;
      case "WebNavigation:GotoIndex":
        this.gotoIndex(message.data);
        break;
      case "WebNavigation:LoadURI":
        this.loadURI(message.data);
        break;
      case "WebNavigation:SetOriginAttributes":
        this.setOriginAttributes(message.data.originAttributes);
        break;
      case "WebNavigation:Reload":
        this.reload(message.data.loadFlags);
        break;
      case "WebNavigation:Stop":
        this.stop(message.data.loadFlags);
        break;
    }
  }

  _wrapURIChangeCall(fn) {
    try {
      fn();
    } finally {
      this.mm.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
        .getInterface(Ci.nsIBrowserChild)
        .notifyNavigationFinished();
    }
  }

  goBack(params) {
    if (this.webNavigation.canGoBack) {
      this.mm.docShell.setCancelContentJSEpoch(params.cancelContentJSEpoch);
      this._wrapURIChangeCall(() => this.webNavigation.goBack());
    }
  }

  goForward(params) {
    if (this.webNavigation.canGoForward) {
      this.mm.docShell.setCancelContentJSEpoch(params.cancelContentJSEpoch);
      this._wrapURIChangeCall(() => this.webNavigation.goForward());
    }
  }

  gotoIndex(params) {
    let {
      index,
      cancelContentJSEpoch,
    } = params || {};
    this.mm.docShell.setCancelContentJSEpoch(cancelContentJSEpoch);
    this._wrapURIChangeCall(() => this.webNavigation.gotoIndex(index));
  }

  loadURI(params) {
    let {
      uri,
      loadFlags,
      referrerInfo,
      postData,
      headers,
      baseURI,
      triggeringPrincipal,
      csp,
      cancelContentJSEpoch,
    } = params || {};

    if (AppConstants.MOZ_CRASHREPORTER && CrashReporter.enabled) {
      let annotation = uri;
      try {
        let url = Services.io.newURI(uri);
        // If the current URI contains a username/password, remove it.
        url = url.mutate()
                 .setUserPass("")
                 .finalize();
        annotation = url.spec;
      } catch (ex) { /* Ignore failures to parse and failures
                      on about: URIs. */ }
      CrashReporter.annotateCrashReport("URL", annotation);
    }
    if (postData)
      postData = E10SUtils.makeInputStream(postData);
    if (headers)
      headers = E10SUtils.makeInputStream(headers);
    if (baseURI)
      baseURI = Services.io.newURI(baseURI);
    this._assert(triggeringPrincipal, "We need a triggering principal to continue loading", new Error().lineNumber);

    triggeringPrincipal = E10SUtils.deserializePrincipal(triggeringPrincipal, () => {
      this._assert(false, "Unable to deserialize passed triggering principal", new Error().lineNumber);
      return Services.scriptSecurityManager.getSystemPrincipal({});
    });
    if (csp) {
      csp = E10SUtils.deserializeCSP(csp);
    }

    let loadURIOptions = {
      triggeringPrincipal,
      csp,
      loadFlags,
      referrerInfo: E10SUtils.deserializeReferrerInfo(referrerInfo),
      postData,
      headers,
      baseURI,
    };
    this.mm.docShell.setCancelContentJSEpoch(cancelContentJSEpoch);
    this._wrapURIChangeCall(() => {
      return this.webNavigation.loadURI(uri, loadURIOptions);
    });
  }

  _assert(condition, msg, line = 0) {
    let debug = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);
    if (!condition && debug.isDebugBuild) {
      debug.warning(`${msg} - ${new Error().stack}`, "WebNavigationChild.js", line);
      debug.abort("WebNavigationChild.js", line);
    }
  }

  setOriginAttributes(originAttributes) {
    if (originAttributes) {
      this.webNavigation.setOriginAttributesBeforeLoading(originAttributes);
    }
  }

  reload(loadFlags) {
    this.webNavigation.reload(loadFlags);
  }

  stop(loadFlags) {
    this.webNavigation.stop(loadFlags);
  }
}