Attachment #525386 for bug #570341

Attachment #525386: pref-out 'performance' prop, unload collecting corrected for bug #570341

View | Details | Raw Unified | Return to bug 570341
Collapse All | Expand All





class nsBindingManager;
class nsIDOMNodeList;
class mozAutoSubtreeModified;
struct JSObject;
class nsFrameLoader;
class nsIBoxObject;
class imgIRequest;
class nsISHEntry;
class nsDOMNavigationTiming;

namespace mozilla {
namespace css {
class Loader;
} // namespace css

namespace dom {
class Link;

  virtual nsresult AddImage(imgIRequest* aImage) = 0;
  virtual nsresult RemoveImage(imgIRequest* aImage) = 0;

  // Makes the images on this document locked/unlocked. By default, the locking
  // state is unlocked/false.
  virtual nsresult SetImageLockingState(PRBool aLocked) = 0;

  virtual nsresult GetMozCurrentStateObject(nsIVariant** aResult) = 0;
  
  virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0;

  virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0;


protected:
  ~nsIDocument()
  {
    // XXX The cleanup of mNodeInfoManager (calling DropDocumentReference and
    //     releasing it) happens in the nsDocument destructor. We'd prefer to
    //     do it here but nsNodeInfoManager is a concrete class that we don't
    //     want to expose to users of the nsIDocument API outside of Gecko.





#include "nsEscape.h"
#ifdef MOZ_MEDIA
#include "nsHTMLMediaElement.h"
#endif // MOZ_MEDIA

#include "mozAutoDocUpdate.h"
#include "nsGlobalWindow.h"
#include "mozilla/dom/indexedDB/IndexedDatabaseManager.h"
#include "nsDOMNavigationTiming.h"

#ifdef MOZ_SMIL
#include "nsSMILAnimationController.h"
#include "imgIContainer.h"
#include "nsSVGUtils.h"
#endif // MOZ_SMIL

#include "nsRefreshDriver.h"

nsDocument::DispatchContentLoadedEvents()
{
  NS_TIME_FUNCTION;
  // If you add early returns from this method, make sure you're
  // calling UnblockOnload properly.
  
  // Unpin references to preloaded images
  mPreloadingImages.Clear();

  if (mTiming) {
    mTiming->NotifyDOMContentLoadedStart(nsIDocument::GetDocumentURI());
  }
    
  // Fire a DOM event notifying listeners that this document has been
  // loaded (excluding images and other loads initiated by this
  // document).
  nsContentUtils::DispatchTrustedEvent(this, static_cast<nsIDocument*>(this),
                                       NS_LITERAL_STRING("DOMContentLoaded"),
                                       PR_TRUE, PR_TRUE);

  if (mTiming) {
    mTiming->NotifyDOMContentLoadedEnd(nsIDocument::GetDocumentURI());
  }
 
  // If this document is a [i]frame, fire a DOMFrameContentLoaded
  // event on all parent documents notifying that the HTML (excluding
  // other external files such as images and stylesheets) in a frame
  // has finished loading.

  // target_frame is the [i]frame element that will be used as the
  // target for the event. It's the [i]frame whose content is done
  // loading.

  clone->mBaseTarget = mBaseTarget;
  return NS_OK;
}

void
nsDocument::SetReadyStateInternal(ReadyState rs)
{
  mReadyState = rs;
  if (mTiming) {
    switch (rs) {
    case READYSTATE_LOADING:
      mTiming->NotifyDOMLoading(nsIDocument::GetDocumentURI());
      break; 
    case READYSTATE_INTERACTIVE:
      mTiming->NotifyDOMInteractive(nsIDocument::GetDocumentURI()); 
      break; 
    case READYSTATE_COMPLETE:
      mTiming->NotifyDOMComplete(nsIDocument::GetDocumentURI());
      break; 
    default:
      NS_WARNING("Unexpected ReadyState value");    
      break; 
    }
  }
  // At the time of loading start, we don't have timing object, record time.
  if (READYSTATE_LOADING == rs) {
    mLoadingTime = PR_Now() / PR_USEC_PER_MSEC;
  }

  nsRefPtr<nsPLDOMEvent> plevent =
    new nsPLDOMEvent(this, NS_LITERAL_STRING("readystatechange"), PR_FALSE, PR_FALSE); 
  if (plevent) {
    plevent->RunDOMEventWhenSafe();
  }
}


    NS_ENSURE_SUCCESS(rv, rv);
  }

  NS_IF_ADDREF(*aState = mCurrentStateObjectCached);
  
  return NS_OK;
}

nsDOMNavigationTiming*
nsDocument::GetNavigationTiming() const
{
  return mTiming;
}

nsresult
nsDocument::SetNavigationTiming(nsDOMNavigationTiming* aTiming)
{
  mTiming = aTiming;
  if (mLoadingTime && mTiming) {
    mTiming->SetDOMLoading(nsIDocument::GetDocumentURI(), mLoadingTime);
  }
  return NS_OK;
}

nsresult
nsDocument::AddImage(imgIRequest* aImage)
{
  NS_ENSURE_ARG_POINTER(aImage);

  // See if the image is already in the hashtable. If it is, get the old count.
  PRUint32 oldCount = 0;
  mImageTracker.Get(aImage, &oldCount);





class nsIFormControl;
struct nsRadioGroupStruct;
class nsOnloadBlocker;
class nsUnblockOnloadEvent;
class nsChildContentList;
class nsXMLEventsManager;
class nsHTMLStyleSheet;
class nsHTMLCSSStyleSheet;
class nsDOMNavigationTiming;

/**
 * Right now our identifier map entries contain information for 'name'
 * and 'id' mappings of a given string. This is so that
 * nsHTMLDocument::ResolveName only has to do one hash lookup instead
 * of two. It's not clear whether this still matters for performance.
 * 
 * We also store the document.all result list here. This is mainly so that

  virtual Element *LookupImageElement(const nsAString& aElementId);

  virtual NS_HIDDEN_(nsresult) AddImage(imgIRequest* aImage);
  virtual NS_HIDDEN_(nsresult) RemoveImage(imgIRequest* aImage);
  virtual NS_HIDDEN_(nsresult) SetImageLockingState(PRBool aLocked);

  virtual nsresult GetMozCurrentStateObject(nsIVariant** aResult);

  virtual nsDOMNavigationTiming* GetNavigationTiming() const;

  virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming);

protected:
  friend class nsNodeUtils;

  /**
   * Check that aId is not empty and log a message to the console
   * service if it is.
   * @returns PR_TRUE if aId looks correct, PR_FALSE otherwise.
   */

   * 2) Removals from the DOM affect the table immediately
   * 3) Additions to the DOM always update existing entries for names, and add
   *    new ones for IDs.
   */
  nsTHashtable<nsIdentifierMapEntry> mIdentifierMap;

  nsClassHashtable<nsStringHashKey, nsRadioGroupStruct> mRadioGroups;

  // Recorded time of change to 'loading' state.
  DOMTimeMilliSec mLoadingTime;

  // True if the document has been detached from its content viewer.
  PRPackedBool mIsGoingAway:1;
  // True if the document is being destroyed.
  PRPackedBool mInDestructor:1;

  // True if this document has ever had an HTML or SVG <title> element
  // bound to it
  PRPackedBool mMayHaveTitleElement:1;

  // any.  This can change during the lifetime of the document.
  nsCOMPtr<nsIApplicationCache> mApplicationCache;

  nsCOMPtr<nsIContent> mFirstBaseNodeWithHref;

  nsEventStates mDocumentState;
  nsEventStates mGotDocumentState;

  nsRefPtr<nsDOMNavigationTiming> mTiming;
private:
  friend class nsUnblockOnloadEvent;

  void PostUnblockOnloadEvent();
  void DoUnblockOnload();

  nsresult CheckFrameOptions();
  nsresult InitCSP();

(-)a/docshell/base/Makefile.in (+1 lines)

Line	Link Here

Lines 113-122 CPPSRCS = \	Link Here

113

# we don't want the shared lib, but we want to force the creation of a

113

# we don't want the shared lib, but we want to force the creation of a

114

# static lib.

114

# static lib.

115

FORCE_STATIC_LIB = 1

115

FORCE_STATIC_LIB = 1

116

117

include $(topsrcdir)/config/rules.mk

117

include $(topsrcdir)/config/rules.mk

118

119

LOCAL_INCLUDES += \

119

LOCAL_INCLUDES += \

120

  -I$(srcdir)/../shistory/src \

120

  -I$(srcdir)/../shistory/src \

121

  -I$(topsrcdir)/dom/base \

121

  -I$(topsrcdir)/layout/base \

122

  -I$(topsrcdir)/layout/base \

122

  $(NULL)

123

  $(NULL)





#endif

#include "nsContentErrors.h"
#include "nsIChannelPolicy.h"
#include "nsIContentSecurityPolicy.h"

#include "nsXULAppAPI.h"

#include "nsDOMNavigationTiming.h"

using namespace mozilla;

// Number of documents currently loading
static PRInt32 gNumberOfDocumentsLoading = 0;

// Global count of existing docshells.
static PRInt32 gDocShellCount = 0;


    return;

  info.numPings = 0;
  info.referrer = referrer;

  ForEachPing(content, SendPing, &info);
}

static nsDOMPerformanceNavigationType
ConvertLoadTypeToNavigationType(PRUint32 aLoadType)
{
    nsDOMPerformanceNavigationType result = nsIDOMPerformanceNavigation::TYPE_RESERVED;
    switch (aLoadType) {
    case LOAD_NORMAL:
    case LOAD_NORMAL_EXTERNAL:
    case LOAD_NORMAL_BYPASS_CACHE:
    case LOAD_NORMAL_BYPASS_PROXY:
    case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
    case LOAD_LINK:
        result = nsIDOMPerformanceNavigation::TYPE_NAVIGATE;
        break;
    case LOAD_HISTORY:
        result = nsIDOMPerformanceNavigation::TYPE_BACK_FORWARD;
        break;
    case LOAD_RELOAD_NORMAL:
    case LOAD_RELOAD_CHARSET_CHANGE:
    case LOAD_RELOAD_BYPASS_CACHE:
    case LOAD_RELOAD_BYPASS_PROXY:
    case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
        result = nsIDOMPerformanceNavigation::TYPE_RELOAD;
        break;
    case LOAD_NORMAL_REPLACE:
    case LOAD_STOP_CONTENT:
    case LOAD_STOP_CONTENT_AND_REPLACE:
    case LOAD_REFRESH:
    case LOAD_BYPASS_HISTORY:
    case LOAD_ERROR_PAGE:
    case LOAD_PUSHSTATE:
        result = nsIDOMPerformanceNavigation::TYPE_RESERVED;
        break;
    default:
        NS_NOTREACHED("Unexpected load type value");
    }

    return result;
}

static nsISHEntry* GetRootSHEntry(nsISHEntry *entry);

//*****************************************************************************
//***    nsDocShell: Object Management
//*****************************************************************************

static PRUint64 gDocshellIDCounter = 0;


nsDocShell::FirePageHideNotification(PRBool aIsUnload)
{
    if (mContentViewer && !mFiredUnloadEvent) {
        // Keep an explicit reference since calling PageHide could release
        // mContentViewer
        nsCOMPtr<nsIContentViewer> kungFuDeathGrip(mContentViewer);
        mFiredUnloadEvent = PR_TRUE;

        if (mTiming) {
            mTiming->NotifyUnloadEventStart();
        }

        mContentViewer->PageHide(aIsUnload);

        if (mTiming) {
            mTiming->NotifyUnloadEventEnd();
        }

        nsAutoTArray<nsCOMPtr<nsIDocShell>, 8> kids;
        PRInt32 i, n = mChildList.Count();
        kids.SetCapacity(n);
        for (i = 0; i < n; i++) {
            kids.AppendElement(do_QueryInterface(ChildAt(i)));
        }

        n = kids.Length();

        // Now make sure our editor, if any, is detached before we go
        // any farther.
        DetachEditorFromWindow();
    }

    return NS_OK;
}

nsresult 
nsDocShell::InitTiming() 
{
    if (mTiming) {
        return NS_OK;
    }

    PRBool enabled;
    nsresult rv = mPrefs->GetBoolPref("dom.enable_performance", &enabled);
    if (NS_SUCCEEDED(rv) && enabled) {
      mTiming = new nsDOMNavigationTiming();
      NS_ENSURE_TRUE(mTiming, NS_ERROR_OUT_OF_MEMORY);
      mTiming->NotifyNavigationStart();
    }
    return NS_OK;
}


//
// Bug 13871: Prevent frameset spoofing
//
// This routine answers: 'Is origin's document from same domain as
// target's document?'
//
// file: uris are considered the same domain for the purpose of
// frame navigation regardless of script accessibility (bug 420425)


NS_IMETHODIMP
nsDocShell::OnStateChange(nsIWebProgress * aProgress, nsIRequest * aRequest,
                          PRUint32 aStateFlags, nsresult aStatus)
{
    nsresult rv;

    if ((~aStateFlags & (STATE_START | STATE_IS_NETWORK)) == 0) {
        // Save timing statistics.
        nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
        // Make sure timing is created
        rv = InitTiming();
        NS_ENSURE_SUCCESS(rv, rv);
        nsCOMPtr<nsIURI> uri;
        channel->GetURI(getter_AddRefs(uri));
        if (mTiming) {
          mTiming->NotifyFetchStart(uri, ConvertLoadTypeToNavigationType(mLoadType));
        }

        nsCOMPtr<nsIWyciwygChannel>  wcwgChannel(do_QueryInterface(aRequest));
        nsCOMPtr<nsIWebProgress> webProgress =
            do_QueryInterface(GetAsSupports(this));

        // Was the wyciwyg document loaded on this docshell?
        if (wcwgChannel && !mLSHE && (mItemType == typeContent) && aProgress == webProgress.get()) {
            nsCOMPtr<nsIURI> uri;
            wcwgChannel->GetURI(getter_AddRefs(uri));
        
            PRBool equalUri = PR_TRUE;
            // Store the wyciwyg url in session history, only if it is
            // being loaded fresh for the first time. We don't want 
            // multiple entries for successive loads
            if (mCurrentURI &&
                NS_SUCCEEDED(uri->Equals(mCurrentURI, &equalUri)) &&
                !equalUri) {


    NS_ASSERTION(aStateFlags & STATE_REDIRECTING,
                 "Calling OnRedirectStateChange when there is no redirect");
    if (!(aStateFlags & STATE_IS_DOCUMENT))
        return; // not a toplevel document

    nsCOMPtr<nsIURI> oldURI, newURI;
    aOldChannel->GetURI(getter_AddRefs(oldURI));
    aNewChannel->GetURI(getter_AddRefs(newURI));

    if (!oldURI || !newURI) {
        return;
    }
    // On session restore we get a redirect from page to itself. Don't count it.
    PRBool equals = PR_FALSE;
    if (mTiming && 
        !(mLoadType == LOAD_HISTORY && 
          NS_SUCCEEDED(newURI->Equals(oldURI, &equals)) && equals)) {
        mTiming->NotifyRedirect(oldURI, newURI);
    }

    // Below a URI visit is saved (see AddURIVisit method doc).
    // The visit chain looks something like:
    //   ...
    //   Site N - 1
    //                =>  Site N
    //   (redirect to =>) Site N + 1 (we are here!)


                        nsIChannel * aChannel, nsresult aStatus)
{
    if(!aChannel)
        return NS_ERROR_NULL_POINTER;
    
    nsCOMPtr<nsIURI> url;
    nsresult rv = aChannel->GetURI(getter_AddRefs(url));
    if (NS_FAILED(rv)) return rv;

    // Timing is picked up by the window, we don't need it anymore
    mTiming = nsnull;

    // clean up reload state for meta charset
    if (eCharsetReloadRequested == mCharsetReloadState)
        mCharsetReloadState = eCharsetReloadStopOrigional;
    else 
        mCharsetReloadState = eCharsetReloadInit;

    // Save a pointer to the currently-loading history entry.
    // nsDocShell::EndPageLoad will clear mLSHE, but we may need this history

  nsCOMPtr<nsIDocShell> kungFuDeathGrip(this);
  
  if (mContentViewer) {
    // We've got a content viewer already. Make sure the user
    // permits us to discard the current document and replace it
    // with about:blank. And also ensure we fire the unload events
    // in the current document.

    // Make sure timing is created. Unload gets fired first for 
    // document loaded from the session history.
    rv = InitTiming();
    if (mTiming) {
      mTiming->NotifyBeforeUnload();
    }

    PRBool okToUnload;
    rv = mContentViewer->PermitUnload(PR_FALSE, &okToUnload);

    if (NS_SUCCEEDED(rv) && !okToUnload) {
      // The user chose not to unload the page, interrupt the load.
      return NS_ERROR_FAILURE;
    }

    mSavingOldViewer = aTryToSaveOldPresentation && 
                       CanSavePresentation(LOAD_NORMAL, nsnull, nsnull);

    if (mTiming) {
      mTiming->NotifyUnloadAccepted(mCurrentURI);
    }
    // Make sure to blow away our mLoadingURI just in case.  No loads
    // from inside this pagehide.
    mLoadingURI = nsnull;
    
    // Notify the current document that it is about to be unloaded!!
    //
    // It is important to fire the unload() notification *before* any state
    // is changed within the DocShell - otherwise, javascript will get the


    mContentViewer = aNewViewer;

    nsCOMPtr<nsIWidget> widget;
    NS_ENSURE_SUCCESS(GetMainWidget(getter_AddRefs(widget)), NS_ERROR_FAILURE);

    nsIntRect bounds(x, y, cx, cy);

    nsCOMPtr<nsIDocumentViewer> docviewer =
        do_QueryInterface(mContentViewer);
    if (docviewer) {
        docviewer->SetNavigationTiming(mTiming);
    }

    if (NS_FAILED(mContentViewer->Init(widget, bounds))) {
        mContentViewer = nsnull;
        NS_ERROR("ContentViewer Initialization failed");
        return NS_ERROR_FAILURE;
    }

    // If we have old state to copy, set the old state onto the new content
    // viewer

        NS_ENSURE_SUCCESS(newMUDV->SetFullZoom(pageZoom),
                          NS_ERROR_FAILURE);
        NS_ENSURE_SUCCESS(newMUDV->SetAuthorStyleDisabled(styleDisabled),
                          NS_ERROR_FAILURE);
    }

    // Stuff the bgcolor from the old pres shell into the new
    // pres shell. This improves page load continuity.
    nsCOMPtr<nsIDocumentViewer> docviewer =
        do_QueryInterface(mContentViewer);

    if (docviewer) {
        nsCOMPtr<nsIPresShell> shell;
        docviewer->GetPresShell(getter_AddRefs(shell));

        if (shell) {
            shell->SetCanvasBackground(bgcolor);
        }
    }

        }
    }
    
    // mContentViewer->PermitUnload can destroy |this| docShell, which
    // causes the next call of CanSavePresentation to crash. 
    // Hold onto |this| until we return, to prevent a crash from happening. 
    // (bug#331040)
    nsCOMPtr<nsIDocShell> kungFuDeathGrip(this);
    
    rv = InitTiming();
    if (mTiming) {
      mTiming->NotifyBeforeUnload();
    }
    // Check if the page doesn't want to be unloaded. The javascript:
    // protocol handler deals with this for javascript: URLs.
    if (!bIsJavascript && mContentViewer) {
        PRBool okToUnload;
        rv = mContentViewer->PermitUnload(PR_FALSE, &okToUnload);

        if (NS_SUCCEEDED(rv) && !okToUnload) {
            // The user chose not to unload the page, interrupt the
            // load.
            return NS_OK;
        }
    }

    if (mTiming) {
      mTiming->NotifyUnloadAccepted(mCurrentURI);
    }

    // Check for saving the presentation here, before calling Stop().
    // This is necessary so that we can catch any pending requests.
    // Since the new request has not been created yet, we pass null for the
    // new request parameter.
    // Also pass nsnull for the document, since it doesn't affect the return
    // value for our purposes here.
    PRBool savePresentation = CanSavePresentation(aLoadType, nsnull, nsnull);


  nsCOMPtr<nsIWebBrowserPrint> result = do_QueryInterface(print);
  result.forget(aPrintPreview);
  return NS_OK;
#else
  return NS_ERROR_NOT_IMPLEMENTED;
#endif
}


#ifdef DEBUG
unsigned long nsDocShell::gNumberOfDocShells = 0;
#endif

NS_IMETHODIMP
nsDocShell::GetCanExecuteScripts(PRBool *aResult)
{
  NS_ENSURE_ARG_POINTER(aResult);





#include "nsIClipboardCommands.h"
#include "nsICommandManager.h"
#include "nsCRT.h"

class nsDocShell;
class nsIController;
class OnLinkClickEvent;
class nsIScrollableFrame;
class nsDOMNavigationTiming;

/* load commands were moved to nsIDocShell.h */
/* load types were moved to nsDocShellLoadTypes.h */

/* internally used ViewMode types */
enum ViewMode {
    viewNormal = 0x0,
    viewSource = 0x1


    nsIChannel* GetCurrentDocChannel();
protected:
    // Override the parent setter from nsDocLoader
    virtual nsresult SetDocLoaderParent(nsDocLoader * aLoader);

    void ClearFrameHistory(nsISHEntry* aEntry);

    nsresult InitTiming();

    // Event type dispatched by RestorePresentation
    class RestorePresentationEvent : public nsRunnable {
    public:
        NS_DECL_NSIRUNNABLE
        RestorePresentationEvent(nsDocShell *ds) : mDocShell(ds) {}
        void Revoke() { mDocShell = nsnull; }
    private:
        nsRefPtr<nsDocShell> mDocShell;

    PRPackedBool               mDynamicallyCreated;
#ifdef DEBUG
    PRPackedBool               mInEnsureScriptEnv;
#endif
    PRUint64                   mHistoryID;

    static nsIURIFixup *sURIFixup;

    nsRefPtr<nsDOMNavigationTiming> mTiming;

#ifdef DEBUG
private:
    // We're counting the number of |nsDocShells| to help find leaks
    static unsigned long gNumberOfDocShells;
#endif /* DEBUG */

public:
    class InterfaceRequestorProxy : public nsIInterfaceRequestor {





		file_bug590573_2.html \
		test_bug598895.html \
		test_bug634834.html \
		file_bug634834.html \
		test_bug637644.html \
		test_framedhistoryframes.html \
		test_windowedhistoryframes.html \
		historyframes.html \
		test_bug570341.html \
		bug570341_recordevents.html \
		$(NULL)

ifeq ($(MOZ_WIDGET_TOOLKIT),cocoa)
_TEST_FILES += \
		test_bug511449.html \
		file_bug511449.html \
		$(NULL)
endif





<html>
<head>
<script>
    var start = Date.now();
    window._testing_js_start = Math.floor(start);
    window._testing_js_start_fine = start;
    window['_testing_js_after_' + document.readyState] = Math.floor(start);
    document.addEventListener('DOMContentLoaded', 
      function () {
        window._testing_evt_DOMContentLoaded = Math.floor(Date.now());
        window._testing_evt_DOMContentLoaded_fine = Date.now();
      }, true);
    document.addEventListener('readystatechange', function(){
      window['_testing_evt_DOM_' + document.readyState] = Math.floor(Date.now());
      window['_testing_evt_DOM_' + document.readyState + '_fine'] = Date.now();
    }, true);
    function recordLoad() {
      window._testing_evt_load = Math.floor(Date.now());
      window._testing_evt_load_fine = Date.now();
    }
</script>
</head>
<body onload="recordLoad()">This document collects time 
for events related to the page load progress.</body>
</html>





<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=570341
-->
<head>
  <title>Test for Bug 570341</title>
  <script type="application/javascript" src="/MochiKit/packed.js"></script>
  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
<script>
  var start = Date.now();
  var moments = {};

  var unload = 0;
  var wasEnabled = true;

  function collectMoments() {
    var win = frames[0];
    var timing = (win.performance && win.performance.timing) || {};
    for (var p in timing) {
      moments[p] = timing[p];
    }
    for (var p in win) {
      if (p.substring(0,9) == '_testing_') {
        moments[p.substring(9)] = win[p];
      }
    }
    moments['evt_unload'] = Math.floor(unload);
    moments['evt_unload_fine'] = unload;
    return moments;
  }

  function showSequence(node){
    while(node.firstChild) {
      node.removeChild(node.firstChild);
    }
    var sequence = [];
    for (var p in moments) {
      sequence.push(p);
    }
    sequence.sort(function(a, b){
      return moments[a] - moments[b];
    });
    table = document.createElement('table');
    node.appendChild(table);
    row = document.createElement('tr');
    table.appendChild(row);
    cell = document.createElement('td');
    row.appendChild(cell);
    cell.appendChild(document.createTextNode('start'));
    cell = document.createElement('td');
    row.appendChild(cell);
    cell.appendChild(document.createTextNode(start));
    for (var i = 0; i < sequence.length; ++i) {
      var prop = sequence[i];
      row = document.createElement('tr');
      table.appendChild(row);
      cell = document.createElement('td');
      row.appendChild(cell);
      cell.appendChild(document.createTextNode(prop));
      cell = document.createElement('td');
      row.appendChild(cell);
      cell.appendChild(document.createTextNode(moments[prop]));
    }
  }

  function checkValues(){
    collectMoments();

    var sequences = [
      ['navigationStart', 'unloadEventStart', 'evt_unload' , 'unloadEventEnd'],
      ['navigationStart', 'fetchStart', 'domainLookupStart', 'domainLookupEnd', 
       'connectStart', 'connectEnd', 'requestStart', 'responseStart', 'responseEnd'],
      ['responseStart', 'domLoading', 'domInteractive', 'domComplete'],
      ['domContentLoadedEventStart', 'evt_DOMContentLoaded', 'domContentLoadedEventEnd',
       'loadEventStart', 'evt_load', 'loadEventEnd']
    ]
    
    for (var i = 0; i < sequences.length; ++i) {
      var seq = sequences[i];
      for (var j = 0; j < seq.length; ++j) {
        var prop = seq[j];
        if (j > 0) {
          var prevProp = seq[j-1];
          ok(moments[prevProp] <= moments[prop], 
              ['Expected ', prevProp, ' to happen before ', prop, 
              ', got ', prevProp, ' = ', moments[prevProp], 
              ', ', prop, ' = ', moments[prop]].join(''));
        }
      }
    }
    try {
      SpecialPowers.setBoolPref('dom.enable_performance', wasEnabled);
    } catch (err) {
      todo(false, 'Exception in SpecialPowers: ' + err + ' at ' + err.stack);
    }

    SimpleTest.finish()
  }

window.onload = function() {
  try {
    wasEnabled = SpecialPowers.getBoolPref('dom.enable_performance');
  } catch (err) {
    todo(false, 'Exception in SpecialPowers: ' + err + ' at ' + err.stack);
  }
  SpecialPowers.setBoolPref('dom.enable_performance', true);

  var win = frames[0];
  win.addEventListener('unload', function(){
    unload = Date.now();
  }, true);
  frames[0].location = 'bug570341_recordevents.html'
  var seenLoad = 0;
  win.addEventListener('load', function (){
    seenLoad = Date.now();
  }, true);
  var interval = setInterval(function () {
    var stopPolling = (win.performance && win.performance.loadEventEnd) ||
                      (seenLoad && Date.now() >= seenLoad + 200);
    if (stopPolling) {
      clearInterval(interval);
      checkValues();
    } else if (win._testing_evt_load) {
      seenLoad = Date.now();
    }
  }, 100);
	}
</script>
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=570341">Mozilla Bug 570341</a>
<div id="frames">
<iframe name="child0" src="navigation/blank.html"></iframe>
</div>
<button type="button" onclick="showSequence(document.getElementById('display'))">
    Show Events</button>
<p id="display"></p>
<div id="content" style="display: none">
  
</div>
<pre id="test">
<script type="application/javascript">
SimpleTest.waitForExplicitFinish();
</script>
</pre>
</body>
</html>





	nsMimeTypeArray.cpp	\
	nsPluginArray.cpp	\
	nsWindowRoot.cpp	\
	nsDOMClassInfo.cpp	\
	nsScriptNameSpaceManager.cpp \
	nsDOMScriptObjectFactory.cpp \
	nsQueryContentEventResult.cpp \
	nsContentPermissionHelper.cpp \
	nsDOMNavigationTiming.cpp \
	nsPerformance.cpp	\
	$(NULL)

include $(topsrcdir)/dom/dom-config.mk

ifdef MOZ_JSDEBUGGER
DEFINES += -DMOZ_JSDEBUGGER
endif






#include "nsIDOMWindowInternal.h"
#include "nsPIDOMWindow.h"
#include "nsIDOMJSWindow.h"
#include "nsIDOMWindowCollection.h"
#include "nsIDOMHistory.h"
#include "nsIDOMMediaList.h"
#include "nsIDOMChromeWindow.h"
#include "nsIDOMConstructor.h"
#include "nsIDOMPerformanceTiming.h"
#include "nsIDOMPerformanceNavigation.h"
#include "nsIDOMPerformance.h"
#include "nsClientRect.h"

// DOM core includes
#include "nsDOMError.h"
#include "nsIDOMDOMException.h"
#include "nsIDOMNode.h"
#include "nsIDOM3Node.h"
#include "nsIDOM3Attr.h"

                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(MimeTypeArray, nsMimeTypeArraySH,
                           ARRAY_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(BarProp, nsDOMGenericSH,
                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(History, nsHistorySH,
                           ARRAY_SCRIPTABLE_FLAGS |
                           nsIXPCScriptable::WANT_PRECREATE)
  NS_DEFINE_CLASSINFO_DATA(PerformanceTiming, nsDOMGenericSH,
                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(PerformanceNavigation, nsDOMGenericSH,
                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(Performance, nsDOMGenericSH,
                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(Screen, nsDOMGenericSH,
                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
  NS_DEFINE_CLASSINFO_DATA(DOMPrototype, nsDOMConstructorSH,
                           DOM_BASE_SCRIPTABLE_FLAGS |
                           nsIXPCScriptable::WANT_PRECREATE |
                           nsIXPCScriptable::WANT_HASINSTANCE |
                           nsIXPCScriptable::DONT_ENUM_QUERY_INTERFACE)
  NS_DEFINE_CLASSINFO_DATA(DOMConstructor, nsDOMConstructorSH,

  NS_ENSURE_SUCCESS(rv, rv);

  JSContext *cx = nsnull;

  rv = stack->GetSafeJSContext(&cx);
  NS_ENSURE_SUCCESS(rv, rv);

  if (nsGlobalWindow::HasIndexedDBSupport()) {
    if (nsGlobalWindow::HasPerformanceSupport()) {
      DOM_CLASSINFO_MAP_BEGIN(Window, nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMJSWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowInternal)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMNSEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMViewCSS)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMAbstractView)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageIndexedDB)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow_2_0_BRANCH)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowPerformance)
      DOM_CLASSINFO_MAP_END
    } else {
      DOM_CLASSINFO_MAP_BEGIN(Window, nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMJSWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowInternal)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMNSEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMViewCSS)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMAbstractView)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageIndexedDB)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow_2_0_BRANCH)
      DOM_CLASSINFO_MAP_END
    }
  } else {
    if (nsGlobalWindow::HasPerformanceSupport()) {
      DOM_CLASSINFO_MAP_BEGIN(Window, nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMJSWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowInternal)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMNSEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMViewCSS)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMAbstractView)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow_2_0_BRANCH)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowPerformance)
      DOM_CLASSINFO_MAP_END
    } else {
      DOM_CLASSINFO_MAP_BEGIN(Window, nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMJSWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowInternal)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMNSEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMViewCSS)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMAbstractView)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMStorageWindow)
        DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindow_2_0_BRANCH)
      DOM_CLASSINFO_MAP_END
    }
  }

  DOM_CLASSINFO_MAP_BEGIN(WindowUtils, nsIDOMWindowUtils)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMWindowUtils)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(Location, nsIDOMLocation)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMLocation)

  DOM_CLASSINFO_MAP_BEGIN(BarProp, nsIDOMBarProp)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMBarProp)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(History, nsIDOMHistory)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMHistory)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(PerformanceTiming, nsIDOMPerformanceTiming)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMPerformanceTiming)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(PerformanceNavigation, nsIDOMPerformanceNavigation)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMPerformanceNavigation)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(Performance, nsIDOMPerformance)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMPerformance)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN(Screen, nsIDOMScreen)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMScreen)
  DOM_CLASSINFO_MAP_END

  DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(DOMPrototype, nsIDOMDOMConstructor)
    DOM_CLASSINFO_MAP_ENTRY(nsIDOMDOMConstructor)
  DOM_CLASSINFO_MAP_END






DOMCI_CLASS(Location)
DOMCI_CLASS(Navigator)
DOMCI_CLASS(Plugin)
DOMCI_CLASS(PluginArray)
DOMCI_CLASS(MimeType)
DOMCI_CLASS(MimeTypeArray)
DOMCI_CLASS(BarProp)
DOMCI_CLASS(History)
DOMCI_CLASS(PerformanceTiming)
DOMCI_CLASS(PerformanceNavigation)
DOMCI_CLASS(Performance)
DOMCI_CLASS(Screen)
DOMCI_CLASS(DOMPrototype)
DOMCI_CLASS(DOMConstructor)

// Core classes
DOMCI_CLASS(XMLDocument)
DOMCI_CLASS(DocumentType)
DOMCI_CLASS(DOMImplementation)





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (lots of improvements)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsDOMNavigationTiming.h"
#include "nsCOMPtr.h"
#include "nscore.h"
#include "prinrval.h"
#include "nsContentUtils.h"

#include "nsIDOMEventTarget.h"
#include "nsIDocument.h"
#include "nsIScriptSecurityManager.h"

nsDOMNavigationTiming::nsDOMNavigationTiming()
{
  Clear();
}

nsDOMNavigationTiming::~nsDOMNavigationTiming()
{
}

void
nsDOMNavigationTiming::Clear()
{
  mNavigationType = nsIDOMPerformanceNavigation::TYPE_RESERVED;
  mNavigationStart = 0;
  mFetchStart = 0;
  mRedirectStart = 0;
  mRedirectEnd = 0;
  mBeforeUnloadStart = 0;
  mUnloadStart = 0;
  mUnloadEnd = 0;
  mLoadEventStart = 0;
  mLoadEventEnd = 0;
  mDOMLoading = 0;
  mDOMInteractive = 0;
  mDOMContentLoadedEventStart = 0;
  mDOMContentLoadedEventEnd = 0;
  mDOMComplete = 0;
  mRedirectCheck = NOT_CHECKED;
}

void
nsDOMNavigationTiming::NotifyNavigationStart()
{
  mNavigationStart = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyFetchStart(nsIURI* aURI, nsDOMPerformanceNavigationType aNavigationType)
{
  mFetchStart = PR_Now() / PR_USEC_PER_MSEC;
  mNavigationType = aNavigationType;
  // At the unload event time we don't really know the loading uri.
  // Need it for later check for unload timing access.
  mLoadedURI = aURI;
}

void
nsDOMNavigationTiming::NotifyRedirect(nsIURI* aOldURI, nsIURI* aNewURI)
{
  if (mRedirects.Count() == 0) {
    mRedirectStart = mFetchStart;
  }
  mFetchStart = PR_Now() / PR_USEC_PER_MSEC;
  mRedirectEnd = mFetchStart;

  // At the unload event time we don't really know the loading uri.
  // Need it for later check for unload timing access.
  mLoadedURI = aNewURI;

  mRedirects.AppendObject(aOldURI);
}

void
nsDOMNavigationTiming::NotifyBeforeUnload()
{
  mBeforeUnloadStart = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyUnloadAccepted(nsIURI* aOldURI)
{
  mUnloadStart = mBeforeUnloadStart;
  mUnloadedURI = aOldURI;
}

void
nsDOMNavigationTiming::NotifyUnloadEventStart()
{
  mUnloadStart = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyUnloadEventEnd()
{
  mUnloadEnd = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyLoadEventStart()
{
  mLoadEventStart = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyLoadEventEnd()
{
  mLoadEventEnd = PR_Now() / PR_USEC_PER_MSEC;
}

PRBool
nsDOMNavigationTiming::ReportRedirects()
{
  if (mRedirectCheck == NOT_CHECKED) {
    if (mRedirects.Count() == 0) {
      mRedirectCheck = NO_REDIRECTS;
    } else {
      mRedirectCheck = CHECK_PASSED;
      nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
      for (int i = mRedirects.Count() - 1; i >= 0; --i) {
        nsIURI * curr = mRedirects[i];
        nsresult rv = ssm->CheckSameOriginURI(curr, mLoadedURI, PR_FALSE);
        if (!NS_SUCCEEDED(rv)) {
          mRedirectCheck = CHECK_FAILED;
          break;
        }
      }
      // All we need to know is in mRedirectCheck now. Clear history.
      mRedirects.Clear();
    }
  }
  return mRedirectCheck == CHECK_PASSED;
}

void
nsDOMNavigationTiming::SetDOMLoading(nsIURI* aURI, DOMTimeMilliSec aValue)
{
  mLoadedURI = aURI;
  mDOMLoading = aValue;
}

void
nsDOMNavigationTiming::NotifyDOMLoading(nsIURI* aURI)
{
  mLoadedURI = aURI;
  mDOMLoading = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyDOMInteractive(nsIURI* aURI)
{
  mLoadedURI = aURI;
  mDOMInteractive = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyDOMComplete(nsIURI* aURI)
{
  mLoadedURI = aURI;
  mDOMComplete = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyDOMContentLoadedStart(nsIURI* aURI)
{
  mLoadedURI = aURI;
  mDOMContentLoadedEventStart = PR_Now() / PR_USEC_PER_MSEC;
}

void
nsDOMNavigationTiming::NotifyDOMContentLoadedEnd(nsIURI* aURI)
{
  mLoadedURI = aURI;
  mDOMContentLoadedEventEnd = PR_Now() / PR_USEC_PER_MSEC;
}


NS_IMPL_ADDREF(nsDOMNavigationTiming)
NS_IMPL_RELEASE(nsDOMNavigationTiming)

// QueryInterface implementation for nsDOMNavigationTiming
NS_INTERFACE_MAP_BEGIN(nsDOMNavigationTiming)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformanceTiming)
  NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceTiming)
  NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceNavigation)
NS_INTERFACE_MAP_END

NS_IMETHODIMP
nsDOMNavigationTiming::GetType(
    nsDOMPerformanceNavigationType* aNavigationType)
{
  *aNavigationType = mNavigationType;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetRedirectCount(PRUint16* aRedirectCount)
{
  *aRedirectCount = 0;
  if (ReportRedirects()) {
    *aRedirectCount = mRedirects.Count();
  }
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetRedirectStart(DOMTimeMilliSec* aRedirectStart)
{
  *aRedirectStart = 0;
  if (ReportRedirects()) {
    *aRedirectStart = mRedirectStart;
  }
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetRedirectEnd(DOMTimeMilliSec* aEnd)
{
  *aEnd = 0;
  if (ReportRedirects()) {
    *aEnd = mRedirectEnd;
  }
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetNavigationStart(DOMTimeMilliSec* aNavigationStart)
{
  *aNavigationStart = mNavigationStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetUnloadEventStart(DOMTimeMilliSec* aStart)
{
  *aStart = 0;
  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
  nsresult rv = ssm->CheckSameOriginURI(mLoadedURI, mUnloadedURI, PR_FALSE);
  if (NS_SUCCEEDED(rv)) {
    *aStart = mUnloadStart;
  }
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetUnloadEventEnd(DOMTimeMilliSec* aEnd)
{
  *aEnd = 0;
  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
  nsresult rv = ssm->CheckSameOriginURI(mLoadedURI, mUnloadedURI, PR_FALSE);
  if (NS_SUCCEEDED(rv)) {
    *aEnd = mUnloadEnd;
  }
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetFetchStart(DOMTimeMilliSec* aStart)
{
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomainLookupStart(DOMTimeMilliSec* aStart)
{
  // TODO: Implement me!
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomainLookupEnd(DOMTimeMilliSec* aEnd)
{
  // TODO: Implement me!
  *aEnd = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetConnectStart(DOMTimeMilliSec* aStart)
{
  // TODO: Implement me!
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetConnectEnd(DOMTimeMilliSec* aEnd)
{
  // TODO: Implement me!
  *aEnd = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetHandshakeStart(DOMTimeMilliSec* aStart)
{
  // TODO: Implement me!
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetRequestStart(DOMTimeMilliSec* aStart)
{
  // TODO: Implement me!
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetResponseStart(DOMTimeMilliSec* aStart)
{
  // TODO: Implement me!
  *aStart = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetResponseEnd(DOMTimeMilliSec* aEnd)
{
  // TODO: Implement me!
  *aEnd = mFetchStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomLoading(DOMTimeMilliSec* aTime)
{
  *aTime = mDOMLoading;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomInteractive(DOMTimeMilliSec* aTime)
{
  *aTime = mDOMInteractive;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomContentLoadedEventStart(DOMTimeMilliSec* aStart)
{
  *aStart = mDOMContentLoadedEventStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomContentLoadedEventEnd(DOMTimeMilliSec* aEnd)
{
  *aEnd = mDOMContentLoadedEventEnd;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetDomComplete(DOMTimeMilliSec* aTime)
{
  *aTime = mDOMComplete;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetLoadEventStart(DOMTimeMilliSec* aStart)
{
  *aStart = mLoadEventStart;
  return NS_OK;
}

NS_IMETHODIMP
nsDOMNavigationTiming::GetLoadEventEnd(DOMTimeMilliSec* aEnd)
{
  *aEnd = mLoadEventEnd;
  return NS_OK;
}






/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (lots of improvements)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef nsDOMNavigationTiming_h___
#define nsDOMNavigationTiming_h___

#include "nsIDOMPerformanceTiming.h"
#include "nsIDOMPerformanceNavigation.h"
#include "nscore.h"
#include "nsCOMPtr.h"
#include "nsCOMArray.h"

class nsDOMNavigationTimingClock;
class nsIURI;
class nsIDocument;

class nsDOMNavigationTiming : public nsIDOMPerformanceTiming,
                              public nsIDOMPerformanceNavigation
{
public:
  nsDOMNavigationTiming();

  NS_DECL_ISUPPORTS
  NS_DECL_NSIDOMPERFORMANCETIMING
  NS_DECL_NSIDOMPERFORMANCENAVIGATION

  void NotifyNavigationStart();
  void NotifyFetchStart(nsIURI* aURI, nsDOMPerformanceNavigationType aNavigationType);
  void NotifyRedirect(nsIURI* aOldURI, nsIURI* aNewURI);
  void NotifyBeforeUnload();
  void NotifyUnloadAccepted(nsIURI* aOldURI);
  void NotifyUnloadEventStart();
  void NotifyUnloadEventEnd();
  void NotifyLoadEventStart();
  void NotifyLoadEventEnd();
  
  // Document changes state to 'loading' before connecting to timing
  void SetDOMLoading(nsIURI* aURI, DOMTimeMilliSec aValue);
  void NotifyDOMLoading(nsIURI* aURI);
  void NotifyDOMInteractive(nsIURI* aURI);
  void NotifyDOMComplete(nsIURI* aURI);
  void NotifyDOMContentLoadedStart(nsIURI* aURI);
  void NotifyDOMContentLoadedEnd(nsIURI* aURI);

private:
  nsDOMNavigationTiming(const nsDOMNavigationTiming &){};
  ~nsDOMNavigationTiming();

  void Clear();
  PRBool ReportRedirects();

  nsCOMPtr<nsIURI> mUnloadedURI;
  nsCOMPtr<nsIURI> mLoadedURI;
  nsCOMArray<nsIURI> mRedirects;

  typedef enum { NOT_CHECKED,
                 CHECK_PASSED, 
                 NO_REDIRECTS, 
                 CHECK_FAILED} RedirectCheckState;
  RedirectCheckState mRedirectCheck;

  nsDOMPerformanceNavigationType mNavigationType;
  DOMTimeMilliSec mNavigationStart;
  DOMTimeMilliSec mFetchStart;
  DOMTimeMilliSec mRedirectStart;
  DOMTimeMilliSec mRedirectEnd;
  DOMTimeMilliSec mBeforeUnloadStart;
  DOMTimeMilliSec mUnloadStart;
  DOMTimeMilliSec mUnloadEnd;
  DOMTimeMilliSec mNavigationEnd;
  DOMTimeMilliSec mLoadEventStart;
  DOMTimeMilliSec mLoadEventEnd;

  DOMTimeMilliSec mDOMLoading;
  DOMTimeMilliSec mDOMInteractive;
  DOMTimeMilliSec mDOMContentLoadedEventStart;
  DOMTimeMilliSec mDOMContentLoadedEventEnd;
  DOMTimeMilliSec mDOMComplete;
};

#endif /* nsDOMNavigationTiming_h___ */






 * ***** END LICENSE BLOCK ***** */

#include "base/basictypes.h"

// Local Includes
#include "nsGlobalWindow.h"
#include "nsScreen.h"
#include "nsHistory.h"
#include "nsPerformance.h"
#include "nsDOMNavigationTiming.h"
#include "nsBarProps.h"
#include "nsDOMStorage.h"
#include "nsDOMOfflineResourceList.h"
#include "nsDOMError.h"

// Helper Classes
#include "nsXPIDLString.h"
#include "nsJSUtils.h"

  mScrollbars = nsnull;
  mLocation = nsnull;
  mHistory = nsnull;
  mFrames = nsnull;
  mApplicationCache = nsnull;
  mIndexedDB = nsnull;
  mPendingStorageEventsObsolete = nsnull;

  mPerformance = nsnull;

  ClearControllers();

  mOpener = nsnull;             // Forces Release
  if (mContext) {
#ifdef DEBUG
    nsCycleCollector_DEBUG_shouldBeFreed(mContext);
#endif

  NS_INTERFACE_MAP_ENTRY(nsPIDOMWindow)
  NS_INTERFACE_MAP_ENTRY(nsIDOMViewCSS)
  NS_INTERFACE_MAP_ENTRY(nsIDOMAbstractView)
  NS_INTERFACE_MAP_ENTRY(nsIDOMStorageWindow)
  NS_INTERFACE_MAP_ENTRY(nsIDOMStorageIndexedDB)
  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
  NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
  NS_INTERFACE_MAP_ENTRY(nsIDOMWindow_2_0_BRANCH)
  NS_INTERFACE_MAP_ENTRY(nsIDOMWindowPerformance)
  NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Window)
  OUTER_WINDOW_ONLY
    NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  END_OUTER_WINDOW_ONLY
NS_INTERFACE_MAP_END


NS_IMPL_CYCLE_COLLECTING_ADDREF(nsGlobalWindow)

      nsEvent event(NS_IS_TRUSTED_EVENT(aVisitor.mEvent), NS_LOAD);
      event.flags |= NS_EVENT_FLAG_CANT_BUBBLE;

      // Most of the time we could get a pres context to pass in here,
      // but not always (i.e. if this window is not shown there won't
      // be a pres context available). Since we're not firing a GUI
      // event we don't need a pres context anyway so we just pass
      // null as the pres context all the time here.

      nsEventDispatcher::Dispatch(content, nsnull, &event, nsnull, &status);
    }
  }

  return NS_OK;
}

nsresult

    }
  }

  NS_IF_ADDREF(*aHistory = mHistory);
  return NS_OK;
}

NS_IMETHODIMP
nsGlobalWindow::GetPerformance(nsIDOMPerformance** aPerformance)
{
  FORWARD_TO_INNER(GetPerformance, (aPerformance), NS_ERROR_NOT_INITIALIZED);

  *aPerformance = nsnull;
  
  if (nsGlobalWindow::HasPerformanceSupport()) {
    if (!mPerformance) {
      nsRefPtr<nsDOMNavigationTiming> timing = mDoc->GetNavigationTiming();
      if (timing) {
        mPerformance = new nsPerformance(timing);
      }
    }
    NS_IF_ADDREF(*aPerformance = mPerformance);
  }
  return NS_OK;
}

NS_IMETHODIMP
nsGlobalWindow::GetParent(nsIDOMWindow** aParent)
{
  FORWARD_TO_OUTER(GetParent, (aParent), NS_ERROR_NOT_INITIALIZED);

  *aParent = nsnull;
  if (!mDocShell)
    return NS_OK;






class nsIScrollableFrame;
class nsIControllers;

class nsBarProp;
class nsLocation;
class nsNavigator;
class nsScreen;
class nsHistory;
class nsPerformance;
class nsIDocShellLoadInfo;
class WindowStateHolder;
class nsGlobalWindowObserver;
class nsGlobalWindow;
class nsDummyJavaPluginOwner;
class PostMessageEvent;
class nsRunnable;


                       public nsIDOMNSEventTarget,
                       public nsIDOMViewCSS,
                       public nsIDOMStorageWindow,
                       public nsIDOMStorageIndexedDB,
                       public nsSupportsWeakReference,
                       public nsIInterfaceRequestor,
                       public nsIDOMWindow_2_0_BRANCH,
                       public nsWrapperCache,
                       public PRCListStr,
                       public nsIDOMWindowPerformance
{
public:
  friend class nsDOMMozURLProperty;

  typedef mozilla::TimeStamp TimeStamp;
  typedef mozilla::TimeDuration TimeDuration;

  // public methods

  NS_DECL_NSIDOMWINDOW

  // nsIDOMWindow2
  NS_DECL_NSIDOMWINDOW2

  // nsIDOMWindowInternal
  NS_DECL_NSIDOMWINDOWINTERNAL

  // nsIDOMWindowPerformance
  NS_DECL_NSIDOMWINDOWPERFORMANCE

  // nsIDOMJSWindow
  NS_DECL_NSIDOMJSWINDOW

  // nsIDOMEventTarget
  NS_DECL_NSIDOMEVENTTARGET

  // nsIDOM3EventTarget
  NS_DECL_NSIDOM3EVENTTARGET

  static nsGlobalWindow* GetOuterWindowWithId(PRUint64 aWindowID) {
    return sOuterWindowsById ? sOuterWindowsById->Get(aWindowID) : nsnull;
  }

  static bool HasIndexedDBSupport() {
    return nsContentUtils::GetBoolPref("indexedDB.feature.enabled", PR_TRUE);
  }

  static bool HasPerformanceSupport() {
#ifdef DEBUG
    return nsContentUtils::GetBoolPref("dom.enable_performance", PR_TRUE);
#else
    return nsContentUtils::GetBoolPref("dom.enable_performance", PR_FALSE);
#endif
  }

private:
  // Enable updates for the accelerometer.
  void EnableAccelerationUpdates();

  // Disables updates for the accelerometer.
  void DisableAccelerationUpdates();

protected:

  nsCOMPtr<nsIScriptContext>    mContext;
  nsWeakPtr                     mOpener;
  nsCOMPtr<nsIControllers>      mControllers;
  nsCOMPtr<nsIArray>            mArguments;
  nsCOMPtr<nsIArray>            mArgumentsLast;
  nsCOMPtr<nsIPrincipal>        mArgumentsOrigin;
  nsRefPtr<nsNavigator>         mNavigator;
  nsRefPtr<nsScreen>            mScreen;
  nsRefPtr<nsPerformance>       mPerformance;
  nsRefPtr<nsDOMWindowList>     mFrames;
  nsRefPtr<nsBarProp>           mMenubar;
  nsRefPtr<nsBarProp>           mToolbar;
  nsRefPtr<nsBarProp>           mLocationbar;
  nsRefPtr<nsBarProp>           mPersonalbar;
  nsRefPtr<nsBarProp>           mStatusbar;
  nsRefPtr<nsBarProp>           mScrollbars;
  nsCOMPtr<nsIWeakReference>    mWindowUtils;





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (update to match bearly-final spec)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsPerformance.h"
#include "nsCOMPtr.h"
#include "nscore.h"
#include "nsIDocShell.h"
#include "nsDOMClassInfo.h"
#include "nsDOMNavigationTiming.h"

DOMCI_DATA(PerformanceTiming, nsPerformanceTiming)

NS_IMPL_ADDREF(nsPerformanceTiming)
NS_IMPL_RELEASE(nsPerformanceTiming)

// QueryInterface implementation for nsPerformanceTiming
NS_INTERFACE_MAP_BEGIN(nsPerformanceTiming)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformanceTiming)
  NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceTiming)
  NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PerformanceTiming)
NS_INTERFACE_MAP_END

nsPerformanceTiming::nsPerformanceTiming(nsDOMNavigationTiming* aData)
{
  NS_ASSERTION(aData, "Timing data should be provided");
  mData = aData;
}

nsPerformanceTiming::~nsPerformanceTiming()
{
}

NS_IMETHODIMP
nsPerformanceTiming::GetNavigationStart(DOMTimeMilliSec* aTime)
{
  return mData->GetNavigationStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetUnloadEventStart(DOMTimeMilliSec* aTime)
{
  return mData->GetUnloadEventStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetUnloadEventEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetUnloadEventEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetRedirectStart(DOMTimeMilliSec* aTime)
{
  return mData->GetRedirectStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetRedirectEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetRedirectEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetFetchStart(DOMTimeMilliSec* aTime)
{
  return mData->GetFetchStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomainLookupStart(DOMTimeMilliSec* aTime)
{
  return mData->GetDomainLookupStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomainLookupEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetDomainLookupEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetConnectStart(DOMTimeMilliSec* aTime)
{
  return mData->GetConnectStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetConnectEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetConnectEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetHandshakeStart(DOMTimeMilliSec* aTime)
{
  return mData->GetHandshakeStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetRequestStart(DOMTimeMilliSec* aTime)
{
  return mData->GetRequestStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetResponseStart(DOMTimeMilliSec* aTime)
{
  return mData->GetResponseStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetResponseEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetResponseEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomLoading(DOMTimeMilliSec* aTime)
{
  return mData->GetDomLoading(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomInteractive(DOMTimeMilliSec* aTime)
{
  return mData->GetDomInteractive(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomContentLoadedEventStart(DOMTimeMilliSec* aTime)
{
  return mData->GetDomContentLoadedEventStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomContentLoadedEventEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetDomContentLoadedEventEnd(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetDomComplete(DOMTimeMilliSec* aTime)
{
  return mData->GetDomComplete(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetLoadEventStart(DOMTimeMilliSec* aTime)
{
  return mData->GetLoadEventStart(aTime);
}

NS_IMETHODIMP
nsPerformanceTiming::GetLoadEventEnd(DOMTimeMilliSec* aTime)
{
  return mData->GetLoadEventEnd(aTime);
}



DOMCI_DATA(PerformanceNavigation, nsPerformanceNavigation)

NS_IMPL_ADDREF(nsPerformanceNavigation)
NS_IMPL_RELEASE(nsPerformanceNavigation)

// QueryInterface implementation for nsPerformanceNavigation
NS_INTERFACE_MAP_BEGIN(nsPerformanceNavigation)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformanceNavigation)
  NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceNavigation)
  NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PerformanceNavigation)
NS_INTERFACE_MAP_END

nsPerformanceNavigation::nsPerformanceNavigation(nsDOMNavigationTiming* aData)
{
  NS_ASSERTION(aData, "Timing data should be provided");
  mData = aData;
}

nsPerformanceNavigation::~nsPerformanceNavigation()
{
}

NS_IMETHODIMP
nsPerformanceNavigation::GetType(
    nsDOMPerformanceNavigationType* aNavigationType)
{
  return mData->GetType(aNavigationType);
}

NS_IMETHODIMP
nsPerformanceNavigation::GetRedirectCount(PRUint16* aRedirectCount)
{
  return mData->GetRedirectCount(aRedirectCount);
}


DOMCI_DATA(Performance, nsPerformance)

NS_IMPL_ADDREF(nsPerformance)
NS_IMPL_RELEASE(nsPerformance)

nsPerformance::nsPerformance(nsDOMNavigationTiming* aTiming)
{
  NS_ASSERTION(aTiming, "Timing data should be provided");
  mData = aTiming;
}

nsPerformance::~nsPerformance()
{
}

// QueryInterface implementation for nsPerformance
NS_INTERFACE_MAP_BEGIN(nsPerformance)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformance)
  NS_INTERFACE_MAP_ENTRY(nsIDOMPerformance)
  NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Performance)
NS_INTERFACE_MAP_END

//
// nsIDOMPerformance methods
//
NS_IMETHODIMP
nsPerformance::GetTiming(nsIDOMPerformanceTiming** aTiming)
{
  if (!mTiming) {
    mTiming = new nsPerformanceTiming(mData);
  }
  NS_IF_ADDREF(*aTiming = mTiming);
  return NS_OK; 
}

NS_IMETHODIMP
nsPerformance::GetNavigation(nsIDOMPerformanceNavigation** aNavigation)
{
  if (!mNavigation) {
    mNavigation = new nsPerformanceNavigation(mData);
  }
  NS_IF_ADDREF(*aNavigation = mNavigation);
  return NS_OK; 
}






/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (update to match bearly-final spec)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */
#ifndef nsPerformance_h___
#define nsPerformance_h___

#include "nsIDOMPerformance.h"
#include "nsIDOMPerformanceTiming.h"
#include "nsIDOMPerformanceNavigation.h"
#include "nscore.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"

class nsIDocument;
class nsIURI;
class nsDOMNavigationTiming;

// Script "performance.timing" object
class nsPerformanceTiming : public nsIDOMPerformanceTiming
{
public:
  nsPerformanceTiming(nsDOMNavigationTiming* data);
  NS_DECL_ISUPPORTS
  NS_DECL_NSIDOMPERFORMANCETIMING
private:
  ~nsPerformanceTiming();
  nsRefPtr<nsDOMNavigationTiming> mData;
};

// Script "performance.navigation" object
class nsPerformanceNavigation : public nsIDOMPerformanceNavigation
{
public:
  nsPerformanceNavigation(nsDOMNavigationTiming* data);
  NS_DECL_ISUPPORTS
  NS_DECL_NSIDOMPERFORMANCENAVIGATION
private:
  ~nsPerformanceNavigation();
  nsRefPtr<nsDOMNavigationTiming> mData;
};

// Script "performance" object
class nsPerformance : public nsIDOMPerformance
{
public:
  nsPerformance(nsDOMNavigationTiming* timing);

  NS_DECL_ISUPPORTS
  NS_DECL_NSIDOMPERFORMANCE

private:
  ~nsPerformance();

  nsRefPtr<nsDOMNavigationTiming> mData;
  nsCOMPtr<nsIDOMPerformanceTiming> mTiming;
  nsCOMPtr<nsIDOMPerformanceNavigation> mNavigation;
};

#endif /* nsPerformance_h___ */


(-)a/dom/interfaces/base/Makefile.in (+3 lines)

Line	Link Here

Lines 81-91 XPIDLSRCS = \	Link Here

	nsIDOMNSFeatureFactory.idl		\

	nsIDOMNSFeatureFactory.idl		\

        nsIDOMClientRect.idl			\

        nsIDOMClientRect.idl			\

        nsIDOMClientRectList.idl		\

        nsIDOMClientRectList.idl		\

	nsIFocusManager.idl			\

	nsIFocusManager.idl			\

	nsIQueryContentEventResult.idl		\

	nsIQueryContentEventResult.idl		\

	nsITabChild.idl				\

	nsITabChild.idl				\

	nsITabParent.idl			\

	nsITabParent.idl			\

	nsIDOMGlobalPropertyInitializer.idl	\

	nsIDOMGlobalPropertyInitializer.idl	\

	nsIDOMPerformance.idl			\

	nsIDOMPerformanceTiming.idl		\

	nsIDOMPerformanceNavigation.idl		\

	$(NULL)

	$(NULL)

include $(topsrcdir)/config/rules.mk

include $(topsrcdir)/config/rules.mk





 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsISupports.idl"

typedef unsigned long long DOMTimeStamp;
typedef unsigned long long DOMTimeMilliSec;

// Core
interface nsIDOMAttr;
interface nsIDOMCDATASection;
interface nsIDOMCharacterData;
interface nsIDOMComment;
interface nsIDOMDOMImplementation;
interface nsIDOMDocument;





/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (update to match nearly-final spec)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsISupports.idl"
interface nsIDOMPerformanceTiming;
interface nsIDOMPerformanceNavigation;

[scriptable, uuid(446faf26-000b-4e66-a5fd-ae37c5ed6beb)]
interface nsIDOMPerformance : nsISupports
{
  readonly attribute nsIDOMPerformanceTiming timing;
  readonly attribute nsIDOMPerformanceNavigation navigation;
};






/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (update to match nearly-final spec)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

typedef unsigned short nsDOMPerformanceNavigationType;

[scriptable, uuid(a2132ad8-a841-4285-a140-338e8de6c2e0)]
interface nsIDOMPerformanceNavigation : nsISupports
{
  const nsDOMPerformanceNavigationType TYPE_NAVIGATE = 0;
  const nsDOMPerformanceNavigationType TYPE_RELOAD = 1;
  const nsDOMPerformanceNavigationType TYPE_BACK_FORWARD = 2;
  const nsDOMPerformanceNavigationType TYPE_RESERVED = 255;

  readonly attribute nsDOMPerformanceNavigationType type;
  readonly attribute unsigned short redirectCount;
};






/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is implementation of Web Timing draft specification
 * http://dev.w3.org/2006/webapi/WebTiming/
 *
 * The Initial Developer of the Original Code is Google Inc.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Sergey Novikov <sergeyn@google.com> (original author)
 *   Igor Bazarny <igor.bazarny@gmail.com> (update to match nearly-final spec)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

[scriptable, uuid(2a630b50-61b6-41b3-996d-70be67fbbcb0)]
interface nsIDOMPerformanceTiming : nsISupports
{
  readonly attribute DOMTimeMilliSec navigationStart;
  readonly attribute DOMTimeMilliSec unloadEventStart;
  readonly attribute DOMTimeMilliSec unloadEventEnd;
  readonly attribute DOMTimeMilliSec redirectStart;
  readonly attribute DOMTimeMilliSec redirectEnd;
  readonly attribute DOMTimeMilliSec fetchStart;
  readonly attribute DOMTimeMilliSec domainLookupStart;
  readonly attribute DOMTimeMilliSec domainLookupEnd;
  readonly attribute DOMTimeMilliSec connectStart;
  readonly attribute DOMTimeMilliSec connectEnd;
  readonly attribute DOMTimeMilliSec handshakeStart;
  readonly attribute DOMTimeMilliSec requestStart;
  readonly attribute DOMTimeMilliSec responseStart;
  readonly attribute DOMTimeMilliSec responseEnd;
  readonly attribute DOMTimeMilliSec domLoading;
  readonly attribute DOMTimeMilliSec domInteractive;
  readonly attribute DOMTimeMilliSec domContentLoadedEventStart;
  readonly attribute DOMTimeMilliSec domContentLoadedEventEnd;
  readonly attribute DOMTimeMilliSec domComplete;
  readonly attribute DOMTimeMilliSec loadEventStart;
  readonly attribute DOMTimeMilliSec loadEventEnd;
};






 *
 * ***** END LICENSE BLOCK ***** */

#include "nsIDOMWindow2.idl"

interface nsIPrompt;
interface nsIControllers;
interface nsIDOMLocation;
interface nsIDOMPerformance;
interface nsIVariant;
interface nsIAnimationFrameListener;

[scriptable, uuid(5930f197-259e-4f6b-aeca-c96a74518cc6)]
interface nsIDOMWindowInternal : nsIDOMWindow2
{
  readonly attribute nsIDOMWindowInternal        window;

  /* [replaceable] self */
  readonly attribute nsIDOMWindowInternal        self;

  readonly attribute nsIDOMNavigator             navigator;

  void revokeObjectURL(in DOMString URL);
};

[scriptable, uuid(05563c0c-b74c-41ad-91d1-bc22d580a581)]
interface nsIDOMWindow_2_0_BRANCH : nsISupports
{
  readonly attribute nsIDOMMozURLProperty URL;
};

[scriptable, uuid(2146c906-57f7-486c-a1b4-8cdb57ef577f)]
interface nsIDOMWindowPerformance : nsISupports
{
  /**
   * A namespace to hold performance related data and statistics.
   */
  readonly attribute nsIDOMPerformance performance;
};






#include "nsIXULDocument.h"
#include "nsXULPopupManager.h"
#endif
#include "nsPrintfCString.h"

#include "nsIClipboardHelper.h"

#include "nsPIDOMWindow.h"
#include "nsDOMNavigationTiming.h"
#include "nsPIWindowRoot.h"
#include "nsJSEnvironment.h"
#include "nsFocusManager.h"

#include "nsIScrollableFrame.h"
#include "nsIHTMLDocument.h"
#include "nsITimelineService.h"
#include "nsGfxCIID.h"

  /**
   * Find the view to use as the container view for MakeWindow. Returns
   * null if this will be the root of a view manager hierarchy. In that
   * case, if mParentWidget is null then this document should not even
   * be displayed.
   */
  virtual nsIView* FindContainerView();

  /**
   * Set collector for navigation timing data (load, unload events).
   */
  virtual void SetNavigationTiming(nsDOMNavigationTiming* timing);

  // nsIContentViewerEdit
  NS_DECL_NSICONTENTVIEWEREDIT

  // nsIContentViewerFile
  NS_DECL_NSICONTENTVIEWERFILE

  // nsIMarkupDocumentViewer
  NS_DECL_NSIMARKUPDOCUMENTVIEWER

    // MakeWindow())...

    rv = InitPresentationStuff(!makeCX);
  }

  return rv;
}

void DocumentViewerImpl::SetNavigationTiming(nsDOMNavigationTiming* timing)
{
  NS_ASSERTION(mDocument, "Must have a document to set navigation timing.");
  if (mDocument) {
    mDocument->SetNavigationTiming(timing);
  }
}

//
// LoadComplete(aStatus)
//
//   aStatus - The status returned from loading the document.
//
// This method is called by the container when the document has been
// completely loaded.
//

    // onload to the document content since that would likely confuse scripts
    // on the page.

    nsIDocShell *docShell = window->GetDocShell();
    NS_ENSURE_TRUE(docShell, NS_ERROR_UNEXPECTED);

    docShell->GetRestoringDocument(&restoring);
    if (!restoring) {
      nsDOMNavigationTiming* timing = mDocument->GetNavigationTiming();
      if (timing) {
        timing->NotifyLoadEventStart();
      }
      nsEventDispatcher::Dispatch(window, mPresContext, &event, nsnull,
                                  &status);
      if (timing) {
        timing->NotifyLoadEventEnd();
      }
#ifdef MOZ_TIMELINE
      // if navigator.xul's load is complete, the main nav window is visible
      // mark that point.

      nsIURI *uri = mDocument ? mDocument->GetDocumentURI() : nsnull;

      if (uri) {
        //printf("DEBUG: getting spec for uri (%p)\n", uri.get());





#include "nsIContentViewer.h"

class nsIDocument;
class nsPresContext;
class nsIPresShell;
class nsIStyleSheet;
class nsIView;

class nsDOMNavigationTiming;

#define NS_IDOCUMENT_VIEWER_IID \
  { 0x5a5c9a1d, 0x49c4, 0x4f3f, \
    { 0x80, 0xcd, 0x12, 0x09, 0x5b, 0x1e, 0x1f, 0x61 } }

/**
 * A document viewer is a kind of content viewer that uses NGLayout
 * to manage the presentation of the content.
 */

  NS_IMETHOD GetPresShell(nsIPresShell** aResult) = 0;
  
  NS_IMETHOD GetPresContext(nsPresContext** aResult) = 0;

  NS_IMETHOD SetDocumentInternal(nsIDocument* aDocument,
                                 PRBool aForceReuseInnerWindow) = 0;

  virtual nsIView* FindContainerView() = 0;

  virtual void SetNavigationTiming(nsDOMNavigationTiming* timing) = 0;
};

NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocumentViewer, NS_IDOCUMENT_VIEWER_IID)

#endif /* nsIDocumentViewer_h___ */

Return to bug 570341