Bugzilla

  SessionHistory.jsm \

/* 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/. */

let EXPORTED_SYMBOLS = ["SessionHistory"];

const Cu = Components.utils;

const Cc = Components.classes;

const Ci = Components.interfaces;

Cu.import("resource://gre/modules/Services.jsm");

Cu.import("resource://gre/modules/XPCOMUtils.jsm");

XPCOMUtils.defineLazyModuleGetter(this, "SessionStore",

  "resource:///modules/sessionstore/SessionStore.jsm");

const PREF_MAX_POSTDATA_LENGTH = "browser.sessionstore.postdata";

function debug(aMsg) {

  aMsg = ("SessionHistory: " + aMsg).replace(/\S{80}/g, "$&\n");

  Services.console.logStringMessage(aMsg);

}

let SessionHistory = {

  getEntries: function sshi_getEntries(aHistory) {

    let entries = [];

    for (let i = 0; i < aHistory.count; i++) {

      try {

        // In some cases, getEntryAtIndex will throw. This seems to be due to

        // history.count being higher than it should be. By doing this in a

        // try-catch, we'll update history to where it breaks, assert for

        // non-release builds, and still save sessionstore.js. We'll track if

        // we've shown the assert for this tab so we only show it once.

        // cf. bug 669196.

        entries.push(aHistory.getEntryAtIndex(i, false));

      } catch (e) {

        let error = new Error("Can't serialize a broken sessionHistory (bug 669196)");

        error.name = "BrokenSessionHistoryError";

        throw error;

      }

    }

    return entries;

  },

  serialize: function sshi_serialize(aDocShell, aFullData) {

    let entries = [];

    let isPinned = aDocShell.isAppTab;

    let shistory = aDocShell.sessionHistory;

    for (let shentry of this.getEntries(shistory)) {

      let entry = SessionHistoryInternal.serializeEntry(shentry, aFullData, isPinned);

      entries.push(entry);

    }

    return entries;

  },

  deserialize: function sshi_deserialize(aDocShell, aEntries) {

    let shistory = aDocShell.sessionHistory.QueryInterface(Ci.nsISHistoryInternal);

    let idMap = { used: {} };

    let docIDMap = {};

    for (let i = 0; i < aEntries.length; i++) {

      let entry = aEntries[i];

      if (entry.url) { //XXXzpao Wallpaper patch for bug 514751

        let shentry = SessionHistoryInternal.deserializeEntry(entry, idMap, docIDMap);

        shistory.addEntry(shentry, true);

      }

    }

  }

};

Object.freeze(SessionHistory);

let SessionHistoryInternal = {

  get postDataMaxLength() {

    return Services.prefs.getIntPref(PREF_MAX_POSTDATA_LENGTH);

  },

  /**

   * Get an object that is a serialized representation of a History entry

   * Used for data storage

   * @param aEntry

   *        nsISHEntry instance

   * @param aFullData

   *        always return privacy sensitive data (use with care)

   * @param aIsPinned

   *        the tab is pinned and should be treated differently for privacy

   * @returns object

   */

  serializeEntry: function ssihi_serializeEntry(aEntry, aFullData, aIsPinned) {

    let uri = aEntry.URI;

    let entry = {url: uri.spec};

    try {

      // Throwing is expensive, we know that about: pages will throw.

      if (entry.url.indexOf("about:") != 0) {

        entry.host = uri.host;

        entry.scheme = uri.scheme;

      }

    } catch (ex) {

      // We'll just not store host and scheme for this entry.

    }

    if (aEntry.title && aEntry.title != entry.url) {

      entry.title = aEntry.title;

    }

    if (aEntry.isSubFrame) {

      entry.subframe = true;

    }

    if (!(aEntry instanceof Ci.nsISHEntry)) {

      return entry;

    }

    let cacheKey = aEntry.cacheKey;

    if (cacheKey && cacheKey instanceof Ci.nsISupportsPRUint32 &&

        cacheKey.data != 0) {

      // XXXbz would be better to have cache keys implement

      // nsISerializable or something.

      entry.cacheKey = cacheKey.data;

    }

    entry.ID = aEntry.ID;

    entry.docshellID = aEntry.docshellID;

    if (aEntry.referrerURI)

      entry.referrer = aEntry.referrerURI.spec;

    if (aEntry.contentType)

      entry.contentType = aEntry.contentType;

    let x = {}, y = {};

    aEntry.getScrollPosition(x, y);

    if (x.value != 0 || y.value != 0)

      entry.scroll = x.value + "," + y.value;

    this._serializePostData(entry, aEntry, aFullData);

    this._serializeOwner(entry, aEntry);

    entry.docIdentifier = aEntry.BFCacheEntry.ID;

    if (aEntry.stateData != null) {

      entry.structuredCloneState = aEntry.stateData.getDataAsBase64();

      entry.structuredCloneVersion = aEntry.stateData.formatVersion;

    }

    if (!(aEntry instanceof Ci.nsISHContainer)) {

      return entry;

    }

    if (aEntry.childCount > 0) {

      let children = [];

      for (let i = 0; i < aEntry.childCount; i++) {

        let child = aEntry.GetChildAt(i);

        if (child) {

          // don't try to restore framesets containing wyciwyg URLs (cf. bug 424689 and bug 450595)

          if (child.URI.schemeIs("wyciwyg")) {

            children = [];

            break;

          }

          children.push(this.serializeEntry(child, aFullData, aIsPinned));

        }

      }

      if (children.length)

        entry.children = children;

    }

    return entry;

  },

  /**

   * expands serialized history data into a session-history-entry instance

   * @param aEntry

   *        Object containing serialized history data for a URL

   * @param aIdMap

   *        Hash for ensuring unique frame IDs

   * @returns nsISHEntry

   */

  deserializeEntry: function ssihi_deserializeEntry(aEntry, aIdMap, aDocIdentMap) {

    let shEntry = Cc["@mozilla.org/browser/session-history-entry;1"]

                    .createInstance(Ci.nsISHEntry);

    shEntry.setURI(Services.io.newURI(aEntry.url, null, null));

    shEntry.setTitle(aEntry.title || aEntry.url);

    if (aEntry.subframe)

      shEntry.setIsSubFrame(aEntry.subframe || false);

    shEntry.loadType = Ci.nsIDocShellLoadInfo.loadHistory;

    if (aEntry.contentType)

      shEntry.contentType = aEntry.contentType;

    if (aEntry.referrer)

      shEntry.referrerURI = Services.io.newURI(aEntry.referrer, null, null)

    if (aEntry.cacheKey) {

      let cacheKey = Cc["@mozilla.org/supports-PRUint32;1"].

                     createInstance(Ci.nsISupportsPRUint32);

      cacheKey.data = aEntry.cacheKey;

      shEntry.cacheKey = cacheKey;

    }

    if (aEntry.ID) {

      // get a new unique ID for this frame (since the one from the last

      // start might already be in use)

      let id = aIdMap[aEntry.ID] || 0;

      if (!id) {

        for (id = Date.now(); id in aIdMap.used; id++);

        aIdMap[aEntry.ID] = id;

        aIdMap.used[id] = true;

      }

      shEntry.ID = id;

    }

    if (aEntry.docshellID)

      shEntry.docshellID = aEntry.docshellID;

    if (aEntry.structuredCloneState && aEntry.structuredCloneVersion) {

      shEntry.stateData =

        Cc["@mozilla.org/docshell/structured-clone-container;1"].

        createInstance(Ci.nsIStructuredCloneContainer);

      shEntry.stateData.initFromBase64(aEntry.structuredCloneState,

                                       aEntry.structuredCloneVersion);

    }

    if (aEntry.scroll) {

      let scrollPos = (aEntry.scroll || "0,0").split(",");

      scrollPos = [parseInt(scrollPos[0]) || 0, parseInt(scrollPos[1]) || 0];

      shEntry.setScrollPosition(scrollPos[0], scrollPos[1]);

    }

    if (aEntry.postdata_b64)

      PostData.deserialize(shEntry, atob(aEntry.postdata_b64))

    let childDocIdents = {};

    if (aEntry.docIdentifier) {

      // If we have a serialized document identifier, try to find an SHEntry

      // which matches that doc identifier and adopt that SHEntry's

      // BFCacheEntry.  If we don't find a match, insert shEntry as the match

      // for the document identifier.

      let matchingEntry = aDocIdentMap[aEntry.docIdentifier];

      if (!matchingEntry) {

        matchingEntry = {shEntry: shEntry, childDocIdents: childDocIdents};

        aDocIdentMap[aEntry.docIdentifier] = matchingEntry;

      }

      else {

        shEntry.adoptBFCacheEntry(matchingEntry.shEntry);

        childDocIdents = matchingEntry.childDocIdents;

      }

    }

    if (aEntry.owner_b64)

      Owner.deserialize(shEntry, atob(aEntry.owner_b64));

    if (aEntry.children && shEntry instanceof Ci.nsISHContainer) {

      for (let i = 0; i < aEntry.children.length; i++) {

        //XXXzpao Wallpaper patch for bug 514751

        if (!aEntry.children[i].url)

          continue;

        // We're getting sessionrestore.js files with a cycle in the

        // doc-identifier graph, likely due to bug 698656.  (That is, we have

        // an entry where doc identifier A is an ancestor of doc identifier B,

        // and another entry where doc identifier B is an ancestor of A.)

        //

        // If we were to respect these doc identifiers, we'd create a cycle in

        // the SHEntries themselves, which causes the docshell to loop forever

        // when it looks for the root SHEntry.

        //

        // So as a hack to fix this, we restrict the scope of a doc identifier

        // to be a node's siblings and cousins, and pass childDocIdents, not

        // aDocIdents, to _deserializeHistoryEntry.  That is, we say that two

        // SHEntries with the same doc identifier have the same document iff

        // they have the same parent or their parents have the same document.

        let child = this.deserializeEntry(aEntry.children[i], aIdMap, childDocIdents);

        shEntry.AddChild(child, i);

      }

    }

    return shEntry;

  },

  _serializePostData: function ssihi_serializePostData(aStore, aEntry, aFullData) {

    if (!aEntry.postData)

      return;

    let isHttps = aEntry.URI.schemeIs("https");

    let maxLength = aFullData ? -1 : this.postDataMaxLength;

    if (maxLength && SessionStore.checkPrivacyLevel(isHttps, aIsPinned)) {

      let postData = PostData.serialize(aEntry, maxLength);

      if (postData) {

        // We can stop doing base64 encoding once our serialization into JSON

        // is guaranteed to handle all chars in strings, including embedded

        // nulls.

        aStore.postdata_b64 = btoa(postData);

      }

    }

  },

  _serializeOwner: function ssihi_serializeOwner(aStore, aEntry) {

    if (!aEntry.owner)

      return;

    let owner = Owner.serialize(aEntry);

    if (owner) {

      // We can stop doing base64 encoding once our serialization into JSON

      // is guaranteed to handle all chars in strings, including embedded

      // nulls.

      aStore.owner_b64 = btoa(owner);

    }

  }

};

let PostData = {

  REGEX_CONTENT_LENGTH: /^(Content-.*\r\n)+(\r\n)*/,

  serialize: function PostData_serialize(aEntry, aMaxLength) {

    try {

      let istream = aEntry.postData.QueryInterface(Ci.nsISeekableStream)

      istream.seek(Ci.nsISeekableStream.NS_SEEK_SET, 0);

      let bistream = Cc["@mozilla.org/binaryinputstream;1"]

                       .createInstance(Ci.nsIBinaryInputStream);

      bistream.setInputStream(aEntry.postData);

      let postBytes = bistream.readByteArray(stream.available());

      let postdata = String.fromCharCode.apply(null, postBytes);

      let re = this.REGEX_CONTENT_LENGTH;

      if (aMaxLength == -1 || postdata.replace(re, "").length <= aMaxLength)

        return postdata;

    } catch (ex) {

      // POSTDATA is tricky - especially since some extensions don't get it right

      debug(ex);

    }

  },

  deserialize: function PostData_deserialize(aEntry, aPostData) {

    let stream = Cc["@mozilla.org/io/string-input-stream;1"]

                   .createInstance(Ci.nsIStringInputStream);

    stream.setData(postdata, postdata.length);

    aEntry.postData = stream;

  }

};

let Owner = {

  serialize: function Owner_serialize(aEntry) {

    try {

      let bostream = Cc["@mozilla.org/binaryoutputstream;1"]

                       .createInstance(Ci.nsIObjectOutputStream);

      let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);

      pipe.init(false, false, 0, 0xffffffff, null);

      bostream.setOutputStream(pipe.outputStream);

      bostream.writeCompoundObject(aEntry.owner, Ci.nsISupports, true);

      bostream.close();

      // Now we want to read the data from the pipe's input end and encode it.

      let bistream = Cc["@mozilla.org/binaryinputstream;1"]

                       .createInstance(Ci.nsIBinaryInputStream);

      bistream.setInputStream(pipe.inputStream);

      let ownerBytes = bistream.readByteArray(bistream.available());

      return String.fromCharCode.apply(null, ownerBytes);

    } catch (ex) {

      // Not catching anything specific here, just possible errors

      // from writeCompoundObject and the like.

      debug(ex);

    }

  },

  deserialize: function Owner_deserialize(aEntry, aData) {

    let sistream = Cc["@mozilla.org/io/string-input-stream;1"]

                     .createInstance(Ci.nsIStringInputStream);

    sistream.setData(aData, aData.length);

    let bistream = Cc["@mozilla.org/binaryinputstream;1"]

                     .createInstance(Ci.nsIObjectInputStream);

    bistream.setInputStream(sistream);

    try {

      aEntry.owner = bistream.readObject(true);

    } catch (ex) {

      // Catch possible deserialization exceptions

      debug(ex);

    }

  }

};