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

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

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

Components.utils.import("resource://gre/modules/AddonManager.jsm");

Components.utils.import("resource:///modules/StringBundle.js");

function tabProgressListener(aTab, aStartsBlank) {

  this.mTab = aTab;

  this.mBrowser = aTab.browser;

  this.mBlank = aStartsBlank;

  this.mProgressListener = null;

}

tabProgressListener.prototype =

{

  mTab: null,

  mBrowser: null,

  mBlank: null,

  mProgressListener: null,

  // cache flags for correct status bar update after tab switching

  mStateFlags: 0,

  mStatus: 0,

  mMessage: "",

  // count of open requests (should always be 0 or 1)

  mRequestCount: 0,

  addProgressListener: function tPL_addProgressListener(aProgressListener) {

    this.mProgressListener = aProgressListener;

  },

  onProgressChange: function tPL_onProgressChange(aWebProgress, aRequest,

                                                  aCurSelfProgress,

                                                  aMaxSelfProgress,

                                                  aCurTotalProgress,

                                                  aMaxTotalProgress) {

    if (this.mProgressListener)

      this.mProgressListener.onProgressChange(aWebProgress, aRequest,

        aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress,

        aMaxTotalProgress);

  },

  onProgressChange64: function tPL_onProgressChange64(aWebProgress, aRequest,

                                                      aCurSelfProgress,

                                                      aMaxSelfProgress,

                                                      aCurTotalProgress,

                                                      aMaxTotalProgress) {

    if (this.mProgressListener)

      this.mProgressListener.onProgressChange64(aWebProgress, aRequest,

        aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress,

        aMaxTotalProgress);

  },

  onLocationChange: function tPL_onLocationChange(aWebProgress, aRequest,

                                                  aLocationURI, aFlags) {

    if (this.mProgressListener)

      this.mProgressListener.onLocationChange(aWebProgress, aRequest,

        aLocationURI, aFlags);

    // onLocationChange is called for both the top-level content

    // and the subframes.

    if (aWebProgress.DOMWindow == this.mBrowser.contentWindow) {

      // Don't clear the favicon if this onLocationChange was triggered

      // by a pushState or a replaceState. See bug 550565.

      if (aWebProgress.isLoadingDocument &&

          !(this.mBrowser.docShell.loadType &

            Components.interfaces.nsIDocShell.LOAD_CMD_PUSHSTATE))

        this.mBrowser.mIconURL = null;

      var location = aLocationURI ? aLocationURI.spec : "";

      // Set the reload command only if this is a report that is coming in about

      // the top-level content location change.

      if (aWebProgress.DOMWindow == this.mBrowser.contentWindow) {

        // Although we're unlikely to be loading about:blank, we'll check it

        // anyway just in case. The second condition is for new tabs, otherwise

        // the reload function is enabled until tab is refreshed.

        this.mTab.reloadEnabled =

          !((location == "about:blank" && !this.mBrowser.contentWindow.opener) ||

            location == "");

      }

    }

  },

  onStateChange: function tPL_onStateChange(aWebProgress, aRequest, aStateFlags,

                                            aStatus) {

    if (this.mProgressListener)

      this.mProgressListener.onStateChange(aWebProgress, aRequest, aStateFlags,

        aStatus);

    if (!aRequest)

      return;

    var oldBlank = this.mBlank;

    const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;

    const nsIChannel = Components.interfaces.nsIChannel;

    let tabmail = document.getElementById("tabmail");

    if (aStateFlags & nsIWebProgressListener.STATE_START) {

      this.mRequestCount++;

    }

    else if (aStateFlags & nsIWebProgressListener.STATE_STOP) {

      // Since we (try to) only handle STATE_STOP of the last request,

      // the count of open requests should now be 0.

      this.mRequestCount = 0;

    }

    if (aStateFlags & nsIWebProgressListener.STATE_START &&

        aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {

      if (!this.mBlank) {

        this.mTab.title = specialTabs.contentTabType.loadingTabString;

        tabmail.setTabBusy(this.mTab, true);

        tabmail.setTabTitle(this.mTab);

      }

      // Set our unit testing variables accordingly

      this.mTab.pageLoading = true;

      this.mTab.pageLoaded = false;

    }

    else if (aStateFlags & nsIWebProgressListener.STATE_STOP &&

             aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {

      this.mBlank = false;

      tabmail.setTabBusy(this.mTab, false);

      tabmail.setTabTitle(this.mTab);

      // Set our unit testing variables accordingly

      this.mTab.pageLoading = false;

      this.mTab.pageLoaded = true;

      // If we've finished loading, and we've not had an icon loaded from a

      // link element, then we try using the default icon for the site.

      if (aWebProgress.DOMWindow == this.mBrowser.contentWindow &&

        !this.mBrowser.mIconURL)

        specialTabs.useDefaultIcon(this.mTab);

    }

  },

  onStatusChange: function tPL_onStatusChange(aWebProgress, aRequest, aStatus,

                                              aMessage) {

    if (this.mProgressListener)

      this.mProgressListener.onStatusChange(aWebProgress, aRequest, aStatus,

        aMessage);

  },

  onSecurityChange: function tPL_onSecurityChange(aWebProgress, aRequest,

                                                  aState) {

    if (this.mProgressListener)

      this.mProgressListener.onSecurityChange(aWebProgress, aRequest, aState);

  },

  onRefreshAttempted: function tPL_OnRefreshAttempted(aWebProgress, aURI,

                                                      aDelay, aSameURI) {

    if (this.mProgressListener)

      this.mProgressListener.onRefreshAttempted(aWebProgress, aURI, aDelay,

        aSameURI);

  },

  QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIWebProgressListener,

                                         Components.interfaces.nsIWebProgressListener2,

                                         Components.interfaces.nsISupportsWeakReference])

};

const DOMLinkHandler = {

  handleEvent: function (event) {

    switch (event.type) {

    case "DOMLinkAdded":

      this.onLinkAdded(event);

      break;

    }

  },

  onLinkAdded: function (event) {

    let link = event.originalTarget;

    let rel = link.rel && link.rel.toLowerCase();

    if (!link || !link.ownerDocument || !rel || !link.href)

      return;

    if (rel.split(/\s+/).indexOf("icon") != -1) {

      if (!Services.prefs.getBoolPref("browser.chrome.site_icons"))

        return;

      let targetDoc = link.ownerDocument;

      let uri = makeURI(link.href, targetDoc.characterSet);

      // Is this a failed icon?

      if (specialTabs.mFaviconService.isFailedFavicon(uri))

        return;

      // Verify that the load of this icon is legal.

      // Some error or special pages can load their favicon.

      // To be on the safe side, only allow chrome:// favicons.

      let isAllowedPage = [

        /^about:neterror\?/,

        /^about:blocked\?/,

        /^about:certerror\?/,

        /^about:home$/

      ].some(function (re) { re.test(targetDoc.documentURI); });

      if (!isAllowedPage || !uri.schemeIs("chrome")) {

        // Be extra paraniod and just make sure we're not going to load

        // something we shouldn't. Firefox does this, so we're doing the same.

        let ssm = Components.classes["@mozilla.org/scriptsecuritymanager;1"]

          .getService(Components.interfaces.nsIScriptSecurityManager);

          try {

            ssm.checkLoadURIWithPrincipal(targetDoc.nodePrincipal, uri,

                                          Components.interfaces.nsIScriptSecurityManager.DISALLOW_SCRIPT);

          }

          catch (ex) {

            return;

          }

      }

      const nsIContentPolicy = Components.interfaces.nsIContentPolicy;

      try {

        var contentPolicy = Components.classes["@mozilla.org/layout/content-policy;1"]

          .getService(nsIContentPolicy);

      }

      catch (e) {

        // Refuse to load if we can't do a security check.

        return;

      }

      // Security says okay, now ask content policy. This is probably trying to

      // ensure that the image loaded always obeys the content policy. There

      // may have been a chance that it was cached and we're trying to load it

      // direct from the cache and not the normal route.

      if (contentPolicy.shouldLoad(nsIContentPolicy.TYPE_IMAGE,

                                   uri, targetDoc.documentURIObject,

                                   link, link.type, null) !=

                                   nsIContentPolicy.ACCEPT)

        return;

      let tab = document.getElementById("tabmail")

                        .getBrowserForDocument(targetDoc.defaultView);

      // If we don't have a browser/tab, then don't load the icon.

      if (!tab)

        return;

      // Just set the url on the browser and we'll display the actual icon

      // when we finish loading the page.

      specialTabs.setTabIcon(tab, link.href);

    }

  }

};

const kTelemetryPrompted    = "toolkit.telemetry.prompted";

const kTelemetryEnabled     = "toolkit.telemetry.enabled";

const kTelemetryServerOwner = "toolkit.telemetry.server_owner";

var contentTabBaseType = {

  inContentWhitelist: ['about:addons'],

  shouldSwitchTo: function onSwitchTo({contentPage: aContentPage}) {

    let tabmail = document.getElementById("tabmail");

    let tabInfo = tabmail.tabInfo;

    // Remove any anchors - especially for the about: pages, we just want

    // to re-use the same tab.

    let regEx = new RegExp("#.*");

    let contentUrl = aContentPage.replace(regEx, "");

    for (let selectedIndex = 0; selectedIndex < tabInfo.length;

         ++selectedIndex) {

      if (tabInfo[selectedIndex].mode.name == this.name &&

          tabInfo[selectedIndex].browser.currentURI.spec

                                .replace(regEx, "") == contentUrl) {

        // Ensure we go to the correct location on the page.

        tabInfo[selectedIndex].browser

                              .setAttribute("src", aContentPage);

        return selectedIndex;

      }

    }

    return -1;

  },

  closeTab: function onTabClosed(aTab) {

    aTab.browser.removeEventListener("DOMTitleChanged",

                                     aTab.titleListener, true);

    aTab.browser.removeEventListener("DOMWindowClose",

                                     aTab.closeListener, true);

    aTab.browser.removeEventListener("DOMLinkAdded", DOMLinkHandler, false);

    gPluginHandler.removeEventListeners(aTab.browser);

    aTab.browser.webProgress.removeProgressListener(aTab.filter);

    aTab.filter.removeProgressListener(aTab.progressListener);

    aTab.browser.destroy();

  },

  saveTabState: function onSaveTabState(aTab) {

    aTab.browser.setAttribute("type", "content-targetable");

  },

  showTab: function onShowTab(aTab) {

    aTab.browser.setAttribute("type", "content-primary");

  },

  getBrowser: function getBrowser(aTab) {

    return aTab.browser;

  },

  hideChromeForLocation: function hideChromeForLocation(aLocation) {

    return this.inContentWhitelist.indexOf(aLocation) != -1;

  },

  /* _setUpLoadListener attaches a load listener to the tab browser that

   * checks the loaded URL to see if it matches the inContentWhitelist.

   * If so, then we apply the disablechrome attribute to the contentTab

   * container.

   */

  _setUpLoadListener: function setUpLoadListener(aTab) {

    let self = this;

    function onLoad(aEvent) {

      let doc = aEvent.originalTarget;

      if (self.hideChromeForLocation(doc.defaultView.location.href)) {

        aTab.root.setAttribute("disablechrome", "true");

      } else {

        doc.documentElement.removeAttribute("disablechrome");

      }

    }

    aTab.loadListener = onLoad;

    aTab.browser.addEventListener("load", aTab.loadListener, true);

  },

  // Internal function used to set up the title listener on a content tab.

  _setUpTitleListener: function setUpTitleListener(aTab) {

    function onDOMTitleChanged(aEvent) {

      aTab.title = aTab.browser.contentTitle;

      document.getElementById("tabmail").setTabTitle(aTab);

    }

    // Save the function we'll use as listener so we can remove it later.

    aTab.titleListener = onDOMTitleChanged;

    // Add the listener.

    aTab.browser.addEventListener("DOMTitleChanged", aTab.titleListener, true);

  },

    /**

     * Internal function used to set up the close window listener on a content

     * tab.

     */

  _setUpCloseWindowListener: function setUpCloseWindowListener(aTab) {

    function onDOMWindowClose(aEvent) {

      if (!aEvent.isTrusted)

        return;

      // Redirect any window.close events to closing the tab. As a 3-pane tab

      // must be open, we don't need to worry about being the last tab open.

      document.getElementById("tabmail").closeTab(aTab);

      aEvent.preventDefault();

    }

    // Save the function we'll use as listener so we can remove it later.

    aTab.closeListener = onDOMWindowClose;

    // Add the listener.

    aTab.browser.addEventListener("DOMWindowClose", aTab.closeListener, true);

  },

  supportsCommand: function supportsCommand(aCommand, aTab) {

    switch (aCommand) {

      case "cmd_fullZoomReduce":

      case "cmd_fullZoomEnlarge":

      case "cmd_fullZoomReset":

      case "cmd_fullZoomToggle":

      case "cmd_find":

      case "cmd_findAgain":

      case "cmd_findPrevious":

      case "cmd_printSetup":

      case "cmd_print":