electron/atom/browser/api/lib/navigation-controller.js

var NavigationController, ipcMain,
  slice = [].slice;

ipcMain = require('electron').ipcMain;


// The history operation in renderer is redirected to browser.

ipcMain.on('ATOM_SHELL_NAVIGATION_CONTROLLER', function() {
  var args, event, method, ref;
  event = arguments[0], method = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
  return (ref = event.sender)[method].apply(ref, args);
});

ipcMain.on('ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', function() {
  var args, event, method, ref;
  event = arguments[0], method = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
  return event.returnValue = (ref = event.sender)[method].apply(ref, args);
});


/*
  JavaScript implementation of Chromium's NavigationController.
  Instead of relying on Chromium for history control, we compeletely do history
  control on user land, and only rely on WebContents.loadURL for navigation.
  This helps us avoid Chromium's various optimizations so we can ensure renderer
  process is restarted everytime.
 */

NavigationController = (function() {
  function NavigationController(webContents) {
    this.webContents = webContents;
    this.clearHistory();

    // webContents may have already navigated to a page.
    if (this.webContents._getURL()) {
      this.currentIndex++;
      this.history.push(this.webContents._getURL());
    }
    this.webContents.on('navigation-entry-commited', (function(_this) {
      return function(event, url, inPage, replaceEntry) {
        var currentEntry;
        if (_this.inPageIndex > -1 && !inPage) {

          // Navigated to a new page, clear in-page mark.
          _this.inPageIndex = -1;
        } else if (_this.inPageIndex === -1 && inPage) {

          // Started in-page navigations.
          _this.inPageIndex = _this.currentIndex;
        }
        if (_this.pendingIndex >= 0) {

          // Go to index.
          _this.currentIndex = _this.pendingIndex;
          _this.pendingIndex = -1;
          return _this.history[_this.currentIndex] = url;
        } else if (replaceEntry) {

          // Non-user initialized navigation.
          return _this.history[_this.currentIndex] = url;
        } else {

          // Normal navigation. Clear history.
          _this.history = _this.history.slice(0, _this.currentIndex + 1);
          currentEntry = _this.history[_this.currentIndex];
          if ((currentEntry != null ? currentEntry.url : void 0) !== url) {
            _this.currentIndex++;
            return _this.history.push(url);
          }
        }
      };
    })(this));
  }

  NavigationController.prototype.loadURL = function(url, options) {
    if (options == null) {
      options = {};
    }
    this.pendingIndex = -1;
    this.webContents._loadURL(url, options);
    return this.webContents.emit('load-url', url, options);
  };

  NavigationController.prototype.getURL = function() {
    if (this.currentIndex === -1) {
      return '';
    } else {
      return this.history[this.currentIndex];
    }
  };

  NavigationController.prototype.stop = function() {
    this.pendingIndex = -1;
    return this.webContents._stop();
  };

  NavigationController.prototype.reload = function() {
    this.pendingIndex = this.currentIndex;
    return this.webContents._loadURL(this.getURL(), {});
  };

  NavigationController.prototype.reloadIgnoringCache = function() {
    this.pendingIndex = this.currentIndex;
    return this.webContents._loadURL(this.getURL(), {
      extraHeaders: "pragma: no-cache\n"
    });
  };

  NavigationController.prototype.canGoBack = function() {
    return this.getActiveIndex() > 0;
  };

  NavigationController.prototype.canGoForward = function() {
    return this.getActiveIndex() < this.history.length - 1;
  };

  NavigationController.prototype.canGoToIndex = function(index) {
    return index >= 0 && index < this.history.length;
  };

  NavigationController.prototype.canGoToOffset = function(offset) {
    return this.canGoToIndex(this.currentIndex + offset);
  };

  NavigationController.prototype.clearHistory = function() {
    this.history = [];
    this.currentIndex = -1;
    this.pendingIndex = -1;
    return this.inPageIndex = -1;
  };

  NavigationController.prototype.goBack = function() {
    if (!this.canGoBack()) {
      return;
    }
    this.pendingIndex = this.getActiveIndex() - 1;
    if (this.inPageIndex > -1 && this.pendingIndex >= this.inPageIndex) {
      return this.webContents._goBack();
    } else {
      return this.webContents._loadURL(this.history[this.pendingIndex], {});
    }
  };

  NavigationController.prototype.goForward = function() {
    if (!this.canGoForward()) {
      return;
    }
    this.pendingIndex = this.getActiveIndex() + 1;
    if (this.inPageIndex > -1 && this.pendingIndex >= this.inPageIndex) {
      return this.webContents._goForward();
    } else {
      return this.webContents._loadURL(this.history[this.pendingIndex], {});
    }
  };

  NavigationController.prototype.goToIndex = function(index) {
    if (!this.canGoToIndex(index)) {
      return;
    }
    this.pendingIndex = index;
    return this.webContents._loadURL(this.history[this.pendingIndex], {});
  };

  NavigationController.prototype.goToOffset = function(offset) {
    var pendingIndex;
    if (!this.canGoToOffset(offset)) {
      return;
    }
    pendingIndex = this.currentIndex + offset;
    if (this.inPageIndex > -1 && pendingIndex >= this.inPageIndex) {
      this.pendingIndex = pendingIndex;
      return this.webContents._goToOffset(offset);
    } else {
      return this.goToIndex(pendingIndex);
    }
  };

  NavigationController.prototype.getActiveIndex = function() {
    if (this.pendingIndex === -1) {
      return this.currentIndex;
    } else {
      return this.pendingIndex;
    }
  };

  NavigationController.prototype.length = function() {
    return this.history.length;
  };

  return NavigationController;

})();

module.exports = NavigationController;