Add m-esr52 at 52.6.0

1 files changed, 1621 insertions, 0 deletions

diff --git a/dom/base/nsContentSink.cpp b/dom/base/nsContentSink.cpp
new file mode 100644
index 000000000..3d6f069d2
--- /dev/null
+++ b/dom/base/nsContentSink.cpp
@@ -0,0 +1,1621 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/*
+ * Base class for the XML and HTML content sinks, which construct a
+ * DOM based on information from the parser.
+ */
+
+#include "nsContentSink.h"
+#include "nsScriptLoader.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "mozilla/css/Loader.h"
+#include "mozilla/dom/SRILogHelper.h"
+#include "nsStyleLinkElement.h"
+#include "nsIDocShell.h"
+#include "nsILoadContext.h"
+#include "nsCPrefetchService.h"
+#include "nsIURI.h"
+#include "nsNetUtil.h"
+#include "nsIMIMEHeaderParam.h"
+#include "nsIProtocolHandler.h"
+#include "nsIHttpChannel.h"
+#include "nsIContent.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+#include "nsViewManager.h"
+#include "nsIAtom.h"
+#include "nsGkAtoms.h"
+#include "nsNetCID.h"
+#include "nsIOfflineCacheUpdate.h"
+#include "nsIApplicationCache.h"
+#include "nsIApplicationCacheContainer.h"
+#include "nsIApplicationCacheChannel.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsICookieService.h"
+#include "nsContentUtils.h"
+#include "nsNodeInfoManager.h"
+#include "nsIAppShell.h"
+#include "nsIWidget.h"
+#include "nsWidgetsCID.h"
+#include "nsIDOMNode.h"
+#include "mozAutoDocUpdate.h"
+#include "nsIWebNavigation.h"
+#include "nsGenericHTMLElement.h"
+#include "nsHTMLDNSPrefetch.h"
+#include "nsIObserverService.h"
+#include "mozilla/Preferences.h"
+#include "nsParserConstants.h"
+#include "nsSandboxFlags.h"
+
+using namespace mozilla;
+
+LazyLogModule gContentSinkLogModuleInfo("nscontentsink");
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsContentSink)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsContentSink)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsContentSink)
+  NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY(nsIDocumentObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+  NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDocumentObserver)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsContentSink)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsContentSink)
+  if (tmp->mDocument) {
+    tmp->mDocument->RemoveObserver(tmp);
+  }
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mParser)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCSSLoader)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mNodeInfoManager)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mScriptLoader)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsContentSink)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParser)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCSSLoader)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNodeInfoManager)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScriptLoader)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+
+nsContentSink::nsContentSink()
+  : mBackoffCount(0)
+  , mLastNotificationTime(0)
+  , mBeganUpdate(0)
+  , mLayoutStarted(0)
+  , mDynamicLowerValue(0)
+  , mParsing(0)
+  , mDroppedTimer(0)
+  , mDeferredLayoutStart(0)
+  , mDeferredFlushTags(0)
+  , mIsDocumentObserver(0)
+  , mRunsToCompletion(0)
+  , mDeflectedCount(0)
+  , mHasPendingEvent(false)
+  , mCurrentParseEndTime(0)
+  , mBeginLoadTime(0)
+  , mLastSampledUserEventTime(0)
+  , mInMonolithicContainer(0)
+  , mInNotification(0)
+  , mUpdatesInNotification(0)
+  , mPendingSheetCount(0)
+{
+  NS_ASSERTION(!mLayoutStarted, "What?");
+  NS_ASSERTION(!mDynamicLowerValue, "What?");
+  NS_ASSERTION(!mParsing, "What?");
+  NS_ASSERTION(mLastSampledUserEventTime == 0, "What?");
+  NS_ASSERTION(mDeflectedCount == 0, "What?");
+  NS_ASSERTION(!mDroppedTimer, "What?");
+  NS_ASSERTION(mInMonolithicContainer == 0, "What?");
+  NS_ASSERTION(mInNotification == 0, "What?");
+  NS_ASSERTION(!mDeferredLayoutStart, "What?");
+}
+
+nsContentSink::~nsContentSink()
+{
+  if (mDocument) {
+    // Remove ourselves just to be safe, though we really should have
+    // been removed in DidBuildModel if everything worked right.
+    mDocument->RemoveObserver(this);
+  }
+}
+
+bool    nsContentSink::sNotifyOnTimer;
+int32_t nsContentSink::sBackoffCount;
+int32_t nsContentSink::sNotificationInterval;
+int32_t nsContentSink::sInteractiveDeflectCount;
+int32_t nsContentSink::sPerfDeflectCount;
+int32_t nsContentSink::sPendingEventMode;
+int32_t nsContentSink::sEventProbeRate;
+int32_t nsContentSink::sInteractiveParseTime;
+int32_t nsContentSink::sPerfParseTime;
+int32_t nsContentSink::sInteractiveTime;
+int32_t nsContentSink::sInitialPerfTime;
+int32_t nsContentSink::sEnablePerfMode;
+
+void
+nsContentSink::InitializeStatics()
+{
+  Preferences::AddBoolVarCache(&sNotifyOnTimer,
+                               "content.notify.ontimer", true);
+  // -1 means never.
+  Preferences::AddIntVarCache(&sBackoffCount,
+                              "content.notify.backoffcount", -1);
+  // The gNotificationInterval has a dramatic effect on how long it
+  // takes to initially display content for slow connections.
+  // The current value provides good
+  // incremental display of content without causing an increase
+  // in page load time. If this value is set below 1/10 of second
+  // it starts to impact page load performance.
+  // see bugzilla bug 72138 for more info.
+  Preferences::AddIntVarCache(&sNotificationInterval,
+                              "content.notify.interval", 120000);
+  Preferences::AddIntVarCache(&sInteractiveDeflectCount,
+                              "content.sink.interactive_deflect_count", 0);
+  Preferences::AddIntVarCache(&sPerfDeflectCount,
+                              "content.sink.perf_deflect_count", 200);
+  Preferences::AddIntVarCache(&sPendingEventMode,
+                              "content.sink.pending_event_mode", 1);
+  Preferences::AddIntVarCache(&sEventProbeRate,
+                              "content.sink.event_probe_rate", 1);
+  Preferences::AddIntVarCache(&sInteractiveParseTime,
+                              "content.sink.interactive_parse_time", 3000);
+  Preferences::AddIntVarCache(&sPerfParseTime,
+                              "content.sink.perf_parse_time", 360000);
+  Preferences::AddIntVarCache(&sInteractiveTime,
+                              "content.sink.interactive_time", 750000);
+  Preferences::AddIntVarCache(&sInitialPerfTime,
+                              "content.sink.initial_perf_time", 2000000);
+  Preferences::AddIntVarCache(&sEnablePerfMode,
+                              "content.sink.enable_perf_mode", 0);
+}
+
+nsresult
+nsContentSink::Init(nsIDocument* aDoc,
+                    nsIURI* aURI,
+                    nsISupports* aContainer,
+                    nsIChannel* aChannel)
+{
+  NS_PRECONDITION(aDoc, "null ptr");
+  NS_PRECONDITION(aURI, "null ptr");
+
+  if (!aDoc || !aURI) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  mDocument = aDoc;
+
+  mDocumentURI = aURI;
+  mDocShell = do_QueryInterface(aContainer);
+  mScriptLoader = mDocument->ScriptLoader();
+
+  if (!mRunsToCompletion) {
+    if (mDocShell) {
+      uint32_t loadType = 0;
+      mDocShell->GetLoadType(&loadType);
+      mDocument->SetChangeScrollPosWhenScrollingToRef(
+        (loadType & nsIDocShell::LOAD_CMD_HISTORY) == 0);
+    }
+
+    ProcessHTTPHeaders(aChannel);
+  }
+
+  mCSSLoader = aDoc->CSSLoader();
+
+  mNodeInfoManager = aDoc->NodeInfoManager();
+
+  mBackoffCount = sBackoffCount;
+
+  if (sEnablePerfMode != 0) {
+    mDynamicLowerValue = sEnablePerfMode == 1;
+    FavorPerformanceHint(!mDynamicLowerValue, 0);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsContentSink::StyleSheetLoaded(StyleSheet* aSheet,
+                                bool aWasAlternate,
+                                nsresult aStatus)
+{
+  NS_ASSERTION(!mRunsToCompletion, "How come a fragment parser observed sheets?");
+  if (!aWasAlternate) {
+    NS_ASSERTION(mPendingSheetCount > 0, "How'd that happen?");
+    --mPendingSheetCount;
+
+    if (mPendingSheetCount == 0 &&
+        (mDeferredLayoutStart || mDeferredFlushTags)) {
+      if (mDeferredFlushTags) {
+        FlushTags();
+      }
+      if (mDeferredLayoutStart) {
+        // We might not have really started layout, since this sheet was still
+        // loading.  Do it now.  Probably doesn't matter whether we do this
+        // before or after we unblock scripts, but before feels saner.  Note
+        // that if mDeferredLayoutStart is true, that means any subclass
+        // StartLayout() stuff that needs to happen has already happened, so we
+        // don't need to worry about it.
+        StartLayout(false);
+      }
+
+      // Go ahead and try to scroll to our ref if we have one
+      ScrollToRef();
+    }
+    
+    mScriptLoader->RemoveParserBlockingScriptExecutionBlocker();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsContentSink::ProcessHTTPHeaders(nsIChannel* aChannel)
+{
+  nsCOMPtr<nsIHttpChannel> httpchannel(do_QueryInterface(aChannel));
+  
+  if (!httpchannel) {
+    return NS_OK;
+  }
+
+  // Note that the only header we care about is the "link" header, since we
+  // have all the infrastructure for kicking off stylesheet loads.
+  
+  nsAutoCString linkHeader;
+  
+  nsresult rv = httpchannel->GetResponseHeader(NS_LITERAL_CSTRING("link"),
+                                               linkHeader);
+  if (NS_SUCCEEDED(rv) && !linkHeader.IsEmpty()) {
+    mDocument->SetHeaderData(nsGkAtoms::link,
+                             NS_ConvertASCIItoUTF16(linkHeader));
+
+    NS_ASSERTION(!mProcessLinkHeaderEvent.get(),
+                 "Already dispatched an event?");
+
+    mProcessLinkHeaderEvent =
+      NewNonOwningRunnableMethod(this,
+        &nsContentSink::DoProcessLinkHeader);
+    rv = NS_DispatchToCurrentThread(mProcessLinkHeaderEvent.get());
+    if (NS_FAILED(rv)) {
+      mProcessLinkHeaderEvent.Forget();
+    }
+  }
+  
+  return NS_OK;
+}
+
+nsresult
+nsContentSink::ProcessHeaderData(nsIAtom* aHeader, const nsAString& aValue,
+                                 nsIContent* aContent)
+{
+  nsresult rv = NS_OK;
+  // necko doesn't process headers coming in from the parser
+
+  mDocument->SetHeaderData(aHeader, aValue);
+
+  if (aHeader == nsGkAtoms::setcookie) {
+    // Note: Necko already handles cookies set via the channel.  We can't just
+    // call SetCookie on the channel because we want to do some security checks
+    // here.
+    nsCOMPtr<nsICookieService> cookieServ =
+      do_GetService(NS_COOKIESERVICE_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    // Get a URI from the document principal
+
+    // We use the original codebase in case the codebase was changed
+    // by SetDomain
+
+    // Note that a non-codebase principal (eg the system principal) will return
+    // a null URI.
+    nsCOMPtr<nsIURI> codebaseURI;
+    rv = mDocument->NodePrincipal()->GetURI(getter_AddRefs(codebaseURI));
+    NS_ENSURE_TRUE(codebaseURI, rv);
+
+    nsCOMPtr<nsIChannel> channel;
+    if (mParser) {
+      mParser->GetChannel(getter_AddRefs(channel));
+    }
+
+    rv = cookieServ->SetCookieString(codebaseURI,
+                                     nullptr,
+                                     NS_ConvertUTF16toUTF8(aValue).get(),
+                                     channel);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+  else if (aHeader == nsGkAtoms::msthemecompatible) {
+    // Disable theming for the presshell if the value is no.
+    // XXXbz don't we want to support this as an HTTP header too?
+    nsAutoString value(aValue);
+    if (value.LowerCaseEqualsLiteral("no")) {
+      nsIPresShell* shell = mDocument->GetShell();
+      if (shell) {
+        shell->DisableThemeSupport();
+      }
+    }
+  }
+
+  return rv;
+}
+
+
+void
+nsContentSink::DoProcessLinkHeader()
+{
+  nsAutoString value;
+  mDocument->GetHeaderData(nsGkAtoms::link, value);
+  ProcessLinkHeader(value);
+}
+
+// check whether the Link header field applies to the context resource
+// see <http://tools.ietf.org/html/rfc5988#section-5.2>
+
+bool
+nsContentSink::LinkContextIsOurDocument(const nsSubstring& aAnchor)
+{
+  if (aAnchor.IsEmpty()) {
+    // anchor parameter not present or empty -> same document reference
+    return true;
+  }
+
+  nsIURI* docUri = mDocument->GetDocumentURI();
+
+  // the document URI might contain a fragment identifier ("#...')
+  // we want to ignore that because it's invisible to the server
+  // and just affects the local interpretation in the recipient
+  nsCOMPtr<nsIURI> contextUri;
+  nsresult rv = docUri->CloneIgnoringRef(getter_AddRefs(contextUri));
+  
+  if (NS_FAILED(rv)) {
+    // copying failed
+    return false;
+  }
+  
+  // resolve anchor against context    
+  nsCOMPtr<nsIURI> resolvedUri;
+  rv = NS_NewURI(getter_AddRefs(resolvedUri), aAnchor,
+      nullptr, contextUri);
+  
+  if (NS_FAILED(rv)) {
+    // resolving failed
+    return false;
+  }
+
+  bool same;
+  rv = contextUri->Equals(resolvedUri, &same); 
+  if (NS_FAILED(rv)) {
+    // comparison failed
+    return false;
+  }
+
+  return same;
+}
+
+// Decode a parameter value using the encoding defined in RFC 5987 (in place)
+//
+//   charset  "'" [ language ] "'" value-chars
+//
+// returns true when decoding happened successfully (otherwise leaves
+// passed value alone)
+bool
+nsContentSink::Decode5987Format(nsAString& aEncoded) {
+
+  nsresult rv;
+  nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar =
+  do_GetService(NS_MIMEHEADERPARAM_CONTRACTID, &rv);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsAutoCString asciiValue;
+
+  const char16_t* encstart = aEncoded.BeginReading();
+  const char16_t* encend = aEncoded.EndReading();
+
+  // create a plain ASCII string, aborting if we can't do that
+  // converted form is always shorter than input
+  while (encstart != encend) {
+    if (*encstart > 0 && *encstart < 128) {
+      asciiValue.Append((char)*encstart);
+    } else {
+      return false;
+    }
+    encstart++;
+  }
+
+  nsAutoString decoded;
+  nsAutoCString language;
+
+  rv = mimehdrpar->DecodeRFC5987Param(asciiValue, language, decoded);
+  if (NS_FAILED(rv))
+    return false;
+
+  aEncoded = decoded;
+  return true;
+}
+
+nsresult
+nsContentSink::ProcessLinkHeader(const nsAString& aLinkData)
+{
+  nsresult rv = NS_OK;
+
+  // keep track where we are within the header field
+  bool seenParameters = false;
+
+  // parse link content and call process style link
+  nsAutoString href;
+  nsAutoString rel;
+  nsAutoString title;
+  nsAutoString titleStar;
+  nsAutoString type;
+  nsAutoString media;
+  nsAutoString anchor;
+  nsAutoString crossOrigin;
+
+  crossOrigin.SetIsVoid(true);
+
+  // copy to work buffer
+  nsAutoString stringList(aLinkData);
+
+  // put an extra null at the end
+  stringList.Append(kNullCh);
+
+  char16_t* start = stringList.BeginWriting();
+  char16_t* end   = start;
+  char16_t* last  = start;
+  char16_t  endCh;
+
+  while (*start != kNullCh) {
+    // skip leading space
+    while ((*start != kNullCh) && nsCRT::IsAsciiSpace(*start)) {
+      ++start;
+    }
+
+    end = start;
+    last = end - 1;
+
+    bool wasQuotedString = false;
+    
+    // look for semicolon or comma
+    while (*end != kNullCh && *end != kSemicolon && *end != kComma) {
+      char16_t ch = *end;
+
+      if (ch == kQuote || ch == kLessThan) {
+        // quoted string
+
+        char16_t quote = ch;
+        if (quote == kLessThan) {
+          quote = kGreaterThan;
+        }
+        
+        wasQuotedString = (ch == kQuote);
+        
+        char16_t* closeQuote = (end + 1);
+
+        // seek closing quote
+        while (*closeQuote != kNullCh && quote != *closeQuote) {
+          // in quoted-string, "\" is an escape character
+          if (wasQuotedString && *closeQuote == kBackSlash && *(closeQuote + 1) != kNullCh) {
+            ++closeQuote;
+          }
+
+          ++closeQuote;
+        }
+
+        if (quote == *closeQuote) {
+          // found closer
+
+          // skip to close quote
+          end = closeQuote;
+
+          last = end - 1;
+
+          ch = *(end + 1);
+
+          if (ch != kNullCh && ch != kSemicolon && ch != kComma) {
+            // end string here
+            *(++end) = kNullCh;
+
+            ch = *(end + 1);
+
+            // keep going until semi or comma
+            while (ch != kNullCh && ch != kSemicolon && ch != kComma) {
+              ++end;
+
+              ch = *(end + 1);
+            }
+          }
+        }
+      }
+
+      ++end;
+      ++last;
+    }
+
+    endCh = *end;
+
+    // end string here
+    *end = kNullCh;
+
+    if (start < end) {
+      if ((*start == kLessThan) && (*last == kGreaterThan)) {
+        *last = kNullCh;
+
+        // first instance of <...> wins
+        // also, do not allow hrefs after the first param was seen
+        if (href.IsEmpty() && !seenParameters) {
+          href = (start + 1);
+          href.StripWhitespace();
+        }
+      } else {
+        char16_t* equals = start;
+        seenParameters = true;
+
+        while ((*equals != kNullCh) && (*equals != kEqual)) {
+          equals++;
+        }
+
+        if (*equals != kNullCh) {
+          *equals = kNullCh;
+          nsAutoString  attr(start);
+          attr.StripWhitespace();
+
+          char16_t* value = ++equals;
+          while (nsCRT::IsAsciiSpace(*value)) {
+            value++;
+          }
+
+          if ((*value == kQuote) && (*value == *last)) {
+            *last = kNullCh;
+            value++;
+          }
+
+          if (wasQuotedString) {
+            // unescape in-place
+            char16_t* unescaped = value;
+            char16_t *src = value;
+            
+            while (*src != kNullCh) {
+              if (*src == kBackSlash && *(src + 1) != kNullCh) {
+                src++;
+              }
+              *unescaped++ = *src++;
+            }
+
+            *unescaped = kNullCh;
+          }
+          
+          if (attr.LowerCaseEqualsLiteral("rel")) {
+            if (rel.IsEmpty()) {
+              rel = value;
+              rel.CompressWhitespace();
+            }
+          } else if (attr.LowerCaseEqualsLiteral("title")) {
+            if (title.IsEmpty()) {
+              title = value;
+              title.CompressWhitespace();
+            }
+          } else if (attr.LowerCaseEqualsLiteral("title*")) {
+            if (titleStar.IsEmpty() && !wasQuotedString) {
+              // RFC 5987 encoding; uses token format only, so skip if we get
+              // here with a quoted-string
+              nsAutoString tmp;
+              tmp = value;
+              if (Decode5987Format(tmp)) {
+                titleStar = tmp;
+                titleStar.CompressWhitespace();
+              } else {
+                // header value did not parse, throw it away
+                titleStar.Truncate();
+              }
+            }
+          } else if (attr.LowerCaseEqualsLiteral("type")) {
+            if (type.IsEmpty()) {
+              type = value;
+              type.StripWhitespace();
+            }
+          } else if (attr.LowerCaseEqualsLiteral("media")) {
+            if (media.IsEmpty()) {
+              media = value;
+
+              // The HTML5 spec is formulated in terms of the CSS3 spec,
+              // which specifies that media queries are case insensitive.
+              nsContentUtils::ASCIIToLower(media);
+            }
+          } else if (attr.LowerCaseEqualsLiteral("anchor")) {
+            if (anchor.IsEmpty()) {
+              anchor = value;
+              anchor.StripWhitespace();
+            }
+          } else if (attr.LowerCaseEqualsLiteral("crossorigin")) {
+            if (crossOrigin.IsVoid()) {
+              crossOrigin.SetIsVoid(false);
+              crossOrigin = value;
+              crossOrigin.StripWhitespace();
+            }
+          }
+        }
+      }
+    }
+
+    if (endCh == kComma) {
+      // hit a comma, process what we've got so far
+
+      href.Trim(" \t\n\r\f"); // trim HTML5 whitespace
+      if (!href.IsEmpty() && !rel.IsEmpty()) {
+        rv = ProcessLink(anchor, href, rel,
+                         // prefer RFC 5987 variant over non-I18zed version
+                         titleStar.IsEmpty() ? title : titleStar,
+                         type, media, crossOrigin);
+      }
+
+      href.Truncate();
+      rel.Truncate();
+      title.Truncate();
+      type.Truncate();
+      media.Truncate();
+      anchor.Truncate();
+      crossOrigin.SetIsVoid(true);
+      
+      seenParameters = false;
+    }
+
+    start = ++end;
+  }
+                
+  href.Trim(" \t\n\r\f"); // trim HTML5 whitespace
+  if (!href.IsEmpty() && !rel.IsEmpty()) {
+    rv = ProcessLink(anchor, href, rel,
+                     // prefer RFC 5987 variant over non-I18zed version
+                     titleStar.IsEmpty() ? title : titleStar,
+                     type, media, crossOrigin);
+  }
+
+  return rv;
+}
+
+
+nsresult
+nsContentSink::ProcessLink(const nsSubstring& aAnchor, const nsSubstring& aHref,
+                           const nsSubstring& aRel, const nsSubstring& aTitle,
+                           const nsSubstring& aType, const nsSubstring& aMedia,
+                           const nsSubstring& aCrossOrigin)
+{
+  uint32_t linkTypes =
+    nsStyleLinkElement::ParseLinkTypes(aRel, mDocument->NodePrincipal());
+
+  // The link relation may apply to a different resource, specified
+  // in the anchor parameter. For the link relations supported so far,
+  // we simply abort if the link applies to a resource different to the
+  // one we've loaded
+  if (!LinkContextIsOurDocument(aAnchor)) {
+    return NS_OK;
+  }
+
+  if (!nsContentUtils::PrefetchEnabled(mDocShell)) {
+    return NS_OK;
+  }
+
+  bool hasPrefetch = linkTypes & nsStyleLinkElement::ePREFETCH;
+  // prefetch href if relation is "next" or "prefetch"
+  if (hasPrefetch || (linkTypes & nsStyleLinkElement::eNEXT)) {
+    PrefetchHref(aHref, mDocument, hasPrefetch);
+  }
+
+  if (!aHref.IsEmpty() && (linkTypes & nsStyleLinkElement::eDNS_PREFETCH)) {
+    PrefetchDNS(aHref);
+  }
+
+  if (!aHref.IsEmpty() && (linkTypes & nsStyleLinkElement::ePRECONNECT)) {
+    Preconnect(aHref, aCrossOrigin);
+  }
+
+  // is it a stylesheet link?
+  if (!(linkTypes & nsStyleLinkElement::eSTYLESHEET)) {
+    return NS_OK;
+  }
+
+  bool isAlternate = linkTypes & nsStyleLinkElement::eALTERNATE;
+  return ProcessStyleLink(nullptr, aHref, isAlternate, aTitle, aType,
+                          aMedia);
+}
+
+nsresult
+nsContentSink::ProcessStyleLink(nsIContent* aElement,
+                                const nsSubstring& aHref,
+                                bool aAlternate,
+                                const nsSubstring& aTitle,
+                                const nsSubstring& aType,
+                                const nsSubstring& aMedia)
+{
+  if (aAlternate && aTitle.IsEmpty()) {
+    // alternates must have title return without error, for now
+    return NS_OK;
+  }
+
+  nsAutoString  mimeType;
+  nsAutoString  params;
+  nsContentUtils::SplitMimeType(aType, mimeType, params);
+
+  // see bug 18817
+  if (!mimeType.IsEmpty() && !mimeType.LowerCaseEqualsLiteral("text/css")) {
+    // Unknown stylesheet language
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIURI> url;
+  nsresult rv = NS_NewURI(getter_AddRefs(url), aHref, nullptr,
+                          mDocument->GetDocBaseURI());
+  
+  if (NS_FAILED(rv)) {
+    // The URI is bad, move along, don't propagate the error (for now)
+    return NS_OK;
+  }
+
+  NS_ASSERTION(!aElement ||
+               aElement->NodeType() == nsIDOMNode::PROCESSING_INSTRUCTION_NODE,
+               "We only expect processing instructions here");
+
+  nsAutoString integrity;
+  if (aElement) {
+    aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::integrity, integrity);
+  }
+  if (!integrity.IsEmpty()) {
+    MOZ_LOG(dom::SRILogHelper::GetSriLog(), mozilla::LogLevel::Debug,
+            ("nsContentSink::ProcessStyleLink, integrity=%s",
+             NS_ConvertUTF16toUTF8(integrity).get()));
+  }
+
+  // If this is a fragment parser, we don't want to observe.
+  // We don't support CORS for processing instructions
+  bool isAlternate;
+  rv = mCSSLoader->LoadStyleLink(aElement, url, aTitle, aMedia, aAlternate,
+                                 CORS_NONE, mDocument->GetReferrerPolicy(),
+                                 integrity, mRunsToCompletion ? nullptr : this,
+                                 &isAlternate);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  if (!isAlternate && !mRunsToCompletion) {
+    ++mPendingSheetCount;
+    mScriptLoader->AddParserBlockingScriptExecutionBlocker();
+  }
+
+  return NS_OK;
+}
+
+
+nsresult
+nsContentSink::ProcessMETATag(nsIContent* aContent)
+{
+  NS_ASSERTION(aContent, "missing meta-element");
+
+  nsresult rv = NS_OK;
+
+  // set any HTTP-EQUIV data into document's header data as well as url
+  nsAutoString header;
+  aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
+  if (!header.IsEmpty()) {
+    // Ignore META REFRESH when document is sandboxed from automatic features.
+    nsContentUtils::ASCIIToLower(header);
+    if (nsGkAtoms::refresh->Equals(header) &&
+        (mDocument->GetSandboxFlags() & SANDBOXED_AUTOMATIC_FEATURES)) {
+      return NS_OK;
+    }
+
+    nsAutoString result;
+    aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::content, result);
+    if (!result.IsEmpty()) {
+      nsCOMPtr<nsIAtom> fieldAtom(NS_Atomize(header));
+      rv = ProcessHeaderData(fieldAtom, result, aContent); 
+    }
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
+                            nsGkAtoms::handheldFriendly, eIgnoreCase)) {
+    nsAutoString result;
+    aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::content, result);
+    if (!result.IsEmpty()) {
+      nsContentUtils::ASCIIToLower(result);
+      mDocument->SetHeaderData(nsGkAtoms::handheldFriendly, result);
+    }
+  }
+
+  return rv;
+}
+
+
+void
+nsContentSink::PrefetchHref(const nsAString &aHref,
+                            nsINode *aSource,
+                            bool aExplicit)
+{
+  nsCOMPtr<nsIPrefetchService> prefetchService(do_GetService(NS_PREFETCHSERVICE_CONTRACTID));
+  if (prefetchService) {
+    // construct URI using document charset
+    const nsACString &charset = mDocument->GetDocumentCharacterSet();
+    nsCOMPtr<nsIURI> uri;
+    NS_NewURI(getter_AddRefs(uri), aHref,
+              charset.IsEmpty() ? nullptr : PromiseFlatCString(charset).get(),
+              mDocument->GetDocBaseURI());
+    if (uri) {
+      nsCOMPtr<nsIDOMNode> domNode = do_QueryInterface(aSource);
+      prefetchService->PrefetchURI(uri, mDocumentURI, domNode, aExplicit);
+    }
+  }
+}
+
+void
+nsContentSink::PrefetchDNS(const nsAString &aHref)
+{
+  nsAutoString hostname;
+
+  if (StringBeginsWith(aHref, NS_LITERAL_STRING("//")))  {
+    hostname = Substring(aHref, 2);
+  }
+  else {
+    nsCOMPtr<nsIURI> uri;
+    NS_NewURI(getter_AddRefs(uri), aHref);
+    if (!uri) {
+      return;
+    }
+    nsresult rv;
+    bool isLocalResource = false;
+    rv = NS_URIChainHasFlags(uri, nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
+                             &isLocalResource);
+    if (NS_SUCCEEDED(rv) && !isLocalResource) {
+      nsAutoCString host;
+      uri->GetHost(host);
+      CopyUTF8toUTF16(host, hostname);
+    }
+  }
+
+  if (!hostname.IsEmpty() && nsHTMLDNSPrefetch::IsAllowed(mDocument)) {
+    nsHTMLDNSPrefetch::PrefetchLow(hostname);
+  }
+}
+
+void
+nsContentSink::Preconnect(const nsAString& aHref, const nsAString& aCrossOrigin)
+{
+  // construct URI using document charset
+  const nsACString& charset = mDocument->GetDocumentCharacterSet();
+  nsCOMPtr<nsIURI> uri;
+  NS_NewURI(getter_AddRefs(uri), aHref,
+            charset.IsEmpty() ? nullptr : PromiseFlatCString(charset).get(),
+            mDocument->GetDocBaseURI());
+
+  if (uri && mDocument) {
+    mDocument->MaybePreconnect(uri, dom::Element::StringToCORSMode(aCrossOrigin));
+  }
+}
+
+nsresult
+nsContentSink::SelectDocAppCache(nsIApplicationCache *aLoadApplicationCache,
+                                 nsIURI *aManifestURI,
+                                 bool aFetchedWithHTTPGetOrEquiv,
+                                 CacheSelectionAction *aAction)
+{
+  nsresult rv;
+
+  *aAction = CACHE_SELECTION_NONE;
+
+  nsCOMPtr<nsIApplicationCacheContainer> applicationCacheDocument =
+    do_QueryInterface(mDocument);
+  NS_ASSERTION(applicationCacheDocument,
+               "mDocument must implement nsIApplicationCacheContainer.");
+
+  if (aLoadApplicationCache) {
+    nsCOMPtr<nsIURI> groupURI;
+    rv = aLoadApplicationCache->GetManifestURI(getter_AddRefs(groupURI));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool equal = false;
+    rv = groupURI->Equals(aManifestURI, &equal);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!equal) {
+      // This is a foreign entry, force a reload to avoid loading the foreign
+      // entry. The entry will be marked as foreign to avoid loading it again.
+
+      *aAction = CACHE_SELECTION_RELOAD;
+    }
+    else {
+      // The http manifest attribute URI is equal to the manifest URI of
+      // the cache the document was loaded from - associate the document with
+      // that cache and invoke the cache update process.
+#ifdef DEBUG
+      nsAutoCString docURISpec, clientID;
+      mDocumentURI->GetAsciiSpec(docURISpec);
+      aLoadApplicationCache->GetClientID(clientID);
+      SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+                 SINK_TRACE_CALLS,
+                ("Selection: assigning app cache %s to document %s",
+                  clientID.get(), docURISpec.get()));
+#endif
+
+      rv = applicationCacheDocument->SetApplicationCache(aLoadApplicationCache);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Document will be added as implicit entry to the cache as part of
+      // the update process.
+      *aAction = CACHE_SELECTION_UPDATE;
+    }
+  }
+  else {
+    // The document was not loaded from an application cache
+    // Here we know the manifest has the same origin as the
+    // document. There is call to CheckMayLoad() on it above.
+
+    if (!aFetchedWithHTTPGetOrEquiv) {
+      // The document was not loaded using HTTP GET or equivalent
+      // method. The spec says to run the cache selection algorithm w/o
+      // the manifest specified.
+      *aAction = CACHE_SELECTION_RESELECT_WITHOUT_MANIFEST;
+    }
+    else {
+      // Always do an update in this case
+      *aAction = CACHE_SELECTION_UPDATE;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsContentSink::SelectDocAppCacheNoManifest(nsIApplicationCache *aLoadApplicationCache,
+                                           nsIURI **aManifestURI,
+                                           CacheSelectionAction *aAction)
+{
+  *aManifestURI = nullptr;
+  *aAction = CACHE_SELECTION_NONE;
+
+  nsresult rv;
+
+  if (aLoadApplicationCache) {
+    // The document was loaded from an application cache, use that
+    // application cache as the document's application cache.
+    nsCOMPtr<nsIApplicationCacheContainer> applicationCacheDocument =
+      do_QueryInterface(mDocument);
+    NS_ASSERTION(applicationCacheDocument,
+                 "mDocument must implement nsIApplicationCacheContainer.");
+
+#ifdef DEBUG
+    nsAutoCString docURISpec, clientID;
+    mDocumentURI->GetAsciiSpec(docURISpec);
+    aLoadApplicationCache->GetClientID(clientID);
+    SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+               SINK_TRACE_CALLS,
+             ("Selection, no manifest: assigning app cache %s to document %s",
+               clientID.get(), docURISpec.get()));
+#endif
+
+    rv = applicationCacheDocument->SetApplicationCache(aLoadApplicationCache);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Return the uri and invoke the update process for the selected
+    // application cache.
+    rv = aLoadApplicationCache->GetManifestURI(aManifestURI);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    *aAction = CACHE_SELECTION_UPDATE;
+  }
+
+  return NS_OK;
+}
+
+void
+nsContentSink::ProcessOfflineManifest(nsIContent *aElement)
+{
+  // Only check the manifest for root document nodes.
+  if (aElement != mDocument->GetRootElement()) {
+    return;
+  }
+
+  // Don't bother processing offline manifest for documents
+  // without a docshell
+  if (!mDocShell) {
+    return;
+  }
+
+  // Check for a manifest= attribute.
+  nsAutoString manifestSpec;
+  aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::manifest, manifestSpec);
+  ProcessOfflineManifest(manifestSpec);
+}
+
+void
+nsContentSink::ProcessOfflineManifest(const nsAString& aManifestSpec)
+{
+  // Don't bother processing offline manifest for documents
+  // without a docshell
+  if (!mDocShell) {
+    return;
+  }
+
+  // If this document has been interecepted, let's skip the processing of the
+  // manifest.
+  if (nsContentUtils::IsControlledByServiceWorker(mDocument)) {
+    return;
+  }
+
+  // If the docshell's in private browsing mode, we don't want to do any
+  // manifest processing.
+  nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(mDocShell);
+  if (loadContext->UsePrivateBrowsing()) {
+    return;
+  }
+
+  nsresult rv;
+
+  // Grab the application cache the document was loaded from, if any.
+  nsCOMPtr<nsIApplicationCache> applicationCache;
+
+  nsCOMPtr<nsIApplicationCacheChannel> applicationCacheChannel =
+    do_QueryInterface(mDocument->GetChannel());
+  if (applicationCacheChannel) {
+    bool loadedFromApplicationCache;
+    rv = applicationCacheChannel->GetLoadedFromApplicationCache(
+      &loadedFromApplicationCache);
+    if (NS_FAILED(rv)) {
+      return;
+    }
+
+    if (loadedFromApplicationCache) {
+      rv = applicationCacheChannel->GetApplicationCache(
+        getter_AddRefs(applicationCache));
+      if (NS_FAILED(rv)) {
+        return;
+      }
+    }
+  }
+
+  if (aManifestSpec.IsEmpty() && !applicationCache) {
+    // Not loaded from an application cache, and no manifest
+    // attribute.  Nothing to do here.
+    return;
+  }
+
+  CacheSelectionAction action = CACHE_SELECTION_NONE;
+  nsCOMPtr<nsIURI> manifestURI;
+
+  if (aManifestSpec.IsEmpty()) {
+    action = CACHE_SELECTION_RESELECT_WITHOUT_MANIFEST;
+  }
+  else {
+    nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(manifestURI),
+                                              aManifestSpec, mDocument,
+                                              mDocumentURI);
+    if (!manifestURI) {
+      return;
+    }
+
+    // Documents must list a manifest from the same origin
+    rv = mDocument->NodePrincipal()->CheckMayLoad(manifestURI, true, false);
+    if (NS_FAILED(rv)) {
+      action = CACHE_SELECTION_RESELECT_WITHOUT_MANIFEST;
+    }
+    else {
+      // Only continue if the document has permission to use offline APIs or
+      // when preferences indicate to permit it automatically.
+      if (!nsContentUtils::OfflineAppAllowed(mDocument->NodePrincipal()) &&
+          !nsContentUtils::MaybeAllowOfflineAppByDefault(mDocument->NodePrincipal()) &&
+          !nsContentUtils::OfflineAppAllowed(mDocument->NodePrincipal())) {
+        return;
+      }
+
+      bool fetchedWithHTTPGetOrEquiv = false;
+      nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mDocument->GetChannel()));
+      if (httpChannel) {
+        nsAutoCString method;
+        rv = httpChannel->GetRequestMethod(method);
+        if (NS_SUCCEEDED(rv))
+          fetchedWithHTTPGetOrEquiv = method.EqualsLiteral("GET");
+      }
+
+      rv = SelectDocAppCache(applicationCache, manifestURI,
+                             fetchedWithHTTPGetOrEquiv, &action);
+      if (NS_FAILED(rv)) {
+        return;
+      }
+    }
+  }
+
+  if (action == CACHE_SELECTION_RESELECT_WITHOUT_MANIFEST) {
+    rv = SelectDocAppCacheNoManifest(applicationCache,
+                                     getter_AddRefs(manifestURI),
+                                     &action);
+    if (NS_FAILED(rv)) {
+      return;
+    }
+  }
+
+  switch (action)
+  {
+  case CACHE_SELECTION_NONE:
+    break;
+  case CACHE_SELECTION_UPDATE: {
+    nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
+      do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
+
+    if (updateService) {
+      nsCOMPtr<nsIDOMDocument> domdoc = do_QueryInterface(mDocument);
+      updateService->ScheduleOnDocumentStop(manifestURI, mDocumentURI,
+                                            mDocument->NodePrincipal(), domdoc);
+    }
+    break;
+  }
+  case CACHE_SELECTION_RELOAD: {
+    // This situation occurs only for toplevel documents, see bottom
+    // of SelectDocAppCache method.
+    // The document has been loaded from a different offline cache group than
+    // the manifest it refers to, i.e. this is a foreign entry, mark it as such 
+    // and force a reload to avoid loading it.  The next attempt will not 
+    // choose it.
+
+    applicationCacheChannel->MarkOfflineCacheEntryAsForeign();
+
+    nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(mDocShell);
+
+    webNav->Stop(nsIWebNavigation::STOP_ALL);
+    webNav->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
+    break;
+  }
+  default:
+    NS_ASSERTION(false,
+          "Cache selection algorithm didn't decide on proper action");
+    break;
+  }
+}
+
+void
+nsContentSink::ScrollToRef()
+{
+  mDocument->ScrollToRef();
+}
+
+void
+nsContentSink::StartLayout(bool aIgnorePendingSheets)
+{
+  if (mLayoutStarted) {
+    // Nothing to do here
+    return;
+  }
+  
+  mDeferredLayoutStart = true;
+
+  if (!aIgnorePendingSheets && WaitForPendingSheets()) {
+    // Bail out; we'll start layout when the sheets load
+    return;
+  }
+
+  mDeferredLayoutStart = false;
+
+  // Notify on all our content.  If none of our presshells have started layout
+  // yet it'll be a no-op except for updating our data structures, a la
+  // UpdateChildCounts() (because we don't want to double-notify on whatever we
+  // have right now).  If some of them _have_ started layout, we want to make
+  // sure to flush tags instead of just calling UpdateChildCounts() after we
+  // loop over the shells.
+  FlushTags();
+
+  mLayoutStarted = true;
+  mLastNotificationTime = PR_Now();
+
+  mDocument->SetMayStartLayout(true);
+  nsCOMPtr<nsIPresShell> shell = mDocument->GetShell();
+  // Make sure we don't call Initialize() for a shell that has
+  // already called it. This can happen when the layout frame for
+  // an iframe is constructed *between* the Embed() call for the
+  // docshell in the iframe, and the content sink's call to OpenBody().
+  // (Bug 153815)
+  if (shell && !shell->DidInitialize()) {
+    nsRect r = shell->GetPresContext()->GetVisibleArea();
+    nsCOMPtr<nsIPresShell> shellGrip = shell;
+    nsresult rv = shell->Initialize(r.width, r.height);
+    if (NS_FAILED(rv)) {
+      return;
+    }
+  }
+
+  // If the document we are loading has a reference or it is a
+  // frameset document, disable the scroll bars on the views.
+
+  mDocument->SetScrollToRef(mDocument->GetDocumentURI());
+}
+
+void
+nsContentSink::NotifyAppend(nsIContent* aContainer, uint32_t aStartIndex)
+{
+  if (aContainer->GetUncomposedDoc() != mDocument) {
+    // aContainer is not actually in our document anymore.... Just bail out of
+    // here; notifying on our document for this append would be wrong.
+    return;
+  }
+
+  mInNotification++;
+  
+  {
+    // Scope so we call EndUpdate before we decrease mInNotification
+    MOZ_AUTO_DOC_UPDATE(mDocument, UPDATE_CONTENT_MODEL, !mBeganUpdate);
+    nsNodeUtils::ContentAppended(aContainer,
+                                 aContainer->GetChildAt(aStartIndex),
+                                 aStartIndex);
+    mLastNotificationTime = PR_Now();
+  }
+
+  mInNotification--;
+}
+
+NS_IMETHODIMP
+nsContentSink::Notify(nsITimer *timer)
+{
+  if (mParsing) {
+    // We shouldn't interfere with our normal DidProcessAToken logic
+    mDroppedTimer = true;
+    return NS_OK;
+  }
+  
+  if (WaitForPendingSheets()) {
+    mDeferredFlushTags = true;
+  } else {
+    FlushTags();
+
+    // Now try and scroll to the reference
+    // XXX Should we scroll unconditionally for history loads??
+    ScrollToRef();
+  }
+
+  mNotificationTimer = nullptr;
+  return NS_OK;
+}
+
+bool
+nsContentSink::IsTimeToNotify()
+{
+  if (!sNotifyOnTimer || !mLayoutStarted || !mBackoffCount ||
+      mInMonolithicContainer) {
+    return false;
+  }
+
+  if (WaitForPendingSheets()) {
+    mDeferredFlushTags = true;
+    return false;
+  }
+
+  PRTime now = PR_Now();
+
+  int64_t interval = GetNotificationInterval();
+  int64_t diff = now - mLastNotificationTime;
+
+  if (diff > interval) {
+    mBackoffCount--;
+    return true;
+  }
+
+  return false;
+}
+
+nsresult
+nsContentSink::WillInterruptImpl()
+{
+  nsresult result = NS_OK;
+
+  SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+             SINK_TRACE_CALLS,
+             ("nsContentSink::WillInterrupt: this=%p", this));
+#ifndef SINK_NO_INCREMENTAL
+  if (WaitForPendingSheets()) {
+    mDeferredFlushTags = true;
+  } else if (sNotifyOnTimer && mLayoutStarted) {
+    if (mBackoffCount && !mInMonolithicContainer) {
+      int64_t now = PR_Now();
+      int64_t interval = GetNotificationInterval();
+      int64_t diff = now - mLastNotificationTime;
+
+      // If it's already time for us to have a notification
+      if (diff > interval || mDroppedTimer) {
+        mBackoffCount--;
+        SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+                   SINK_TRACE_REFLOW,
+                   ("nsContentSink::WillInterrupt: flushing tags since we've "
+                    "run out time; backoff count: %d", mBackoffCount));
+        result = FlushTags();
+        if (mDroppedTimer) {
+          ScrollToRef();
+          mDroppedTimer = false;
+        }
+      } else if (!mNotificationTimer) {
+        interval -= diff;
+        int32_t delay = interval;
+
+        // Convert to milliseconds
+        delay /= PR_USEC_PER_MSEC;
+
+        mNotificationTimer = do_CreateInstance("@mozilla.org/timer;1",
+                                               &result);
+        if (NS_SUCCEEDED(result)) {
+          SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+                     SINK_TRACE_REFLOW,
+                     ("nsContentSink::WillInterrupt: setting up timer with "
+                      "delay %d", delay));
+
+          result =
+            mNotificationTimer->InitWithCallback(this, delay,
+                                                 nsITimer::TYPE_ONE_SHOT);
+          if (NS_FAILED(result)) {
+            mNotificationTimer = nullptr;
+          }
+        }
+      }
+    }
+  } else {
+    SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+               SINK_TRACE_REFLOW,
+               ("nsContentSink::WillInterrupt: flushing tags "
+                "unconditionally"));
+    result = FlushTags();
+  }
+#endif
+
+  mParsing = false;
+
+  return result;
+}
+
+nsresult
+nsContentSink::WillResumeImpl()
+{
+  SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+             SINK_TRACE_CALLS,
+             ("nsContentSink::WillResume: this=%p", this));
+
+  mParsing = true;
+
+  return NS_OK;
+}
+
+nsresult
+nsContentSink::DidProcessATokenImpl()
+{
+  if (mRunsToCompletion || !mParser) {
+    return NS_OK;
+  }
+
+  // Get the current user event time
+  nsIPresShell *shell = mDocument->GetShell();
+  if (!shell) {
+    // If there's no pres shell in the document, return early since
+    // we're not laying anything out here.
+    return NS_OK;
+  }
+
+  // Increase before comparing to gEventProbeRate
+  ++mDeflectedCount;
+
+  // Check if there's a pending event
+  if (sPendingEventMode != 0 && !mHasPendingEvent &&
+      (mDeflectedCount % sEventProbeRate) == 0) {
+    nsViewManager* vm = shell->GetViewManager();
+    NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
+    nsCOMPtr<nsIWidget> widget;
+    vm->GetRootWidget(getter_AddRefs(widget));
+    mHasPendingEvent = widget && widget->HasPendingInputEvent();
+  }
+
+  if (mHasPendingEvent && sPendingEventMode == 2) {
+    return NS_ERROR_HTMLPARSER_INTERRUPTED;
+  }
+
+  // Have we processed enough tokens to check time?
+  if (!mHasPendingEvent &&
+      mDeflectedCount < uint32_t(mDynamicLowerValue ? sInteractiveDeflectCount :
+                                                      sPerfDeflectCount)) {
+    return NS_OK;
+  }
+
+  mDeflectedCount = 0;
+
+  // Check if it's time to return to the main event loop
+  if (PR_IntervalToMicroseconds(PR_IntervalNow()) > mCurrentParseEndTime) {
+    return NS_ERROR_HTMLPARSER_INTERRUPTED;
+  }
+
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------
+
+void
+nsContentSink::FavorPerformanceHint(bool perfOverStarvation, uint32_t starvationDelay)
+{
+  static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
+  nsCOMPtr<nsIAppShell> appShell = do_GetService(kAppShellCID);
+  if (appShell)
+    appShell->FavorPerformanceHint(perfOverStarvation, starvationDelay);
+}
+
+void
+nsContentSink::BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)
+{
+  // Remember nested updates from updates that we started.
+  if (mInNotification > 0 && mUpdatesInNotification < 2) {
+    ++mUpdatesInNotification;
+  }
+
+  // If we're in a script and we didn't do the notification,
+  // something else in the script processing caused the
+  // notification to occur. Since this could result in frame
+  // creation, make sure we've flushed everything before we
+  // continue.
+
+  if (!mInNotification++) {
+    FlushTags();
+  }
+}
+
+void
+nsContentSink::EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)
+{
+  // If we're in a script and we didn't do the notification,
+  // something else in the script processing caused the
+  // notification to occur. Update our notion of how much
+  // has been flushed to include any new content if ending
+  // this update leaves us not inside a notification.
+  if (!--mInNotification) {
+    UpdateChildCounts();
+  }
+}
+
+void
+nsContentSink::DidBuildModelImpl(bool aTerminated)
+{
+  if (mDocument) {
+    MOZ_ASSERT(aTerminated ||
+               mDocument->GetReadyStateEnum() ==
+               nsIDocument::READYSTATE_LOADING, "Bad readyState");
+    mDocument->SetReadyStateInternal(nsIDocument::READYSTATE_INTERACTIVE);
+  }
+
+  if (mScriptLoader) {
+    mScriptLoader->ParsingComplete(aTerminated);
+  }
+
+  if (!mDocument->HaveFiredDOMTitleChange()) {
+    mDocument->NotifyPossibleTitleChange(false);
+  }
+
+  // Cancel a timer if we had one out there
+  if (mNotificationTimer) {
+    SINK_TRACE(static_cast<LogModule*>(gContentSinkLogModuleInfo),
+               SINK_TRACE_REFLOW,
+               ("nsContentSink::DidBuildModel: canceling notification "
+                "timeout"));
+    mNotificationTimer->Cancel();
+    mNotificationTimer = nullptr;
+  }	
+}
+
+void
+nsContentSink::DropParserAndPerfHint(void)
+{
+  if (!mParser) {
+    // Make sure we don't unblock unload too many times
+    return;
+  }
+  
+  // Ref. Bug 49115
+  // Do this hack to make sure that the parser
+  // doesn't get destroyed, accidently, before
+  // the circularity, between sink & parser, is
+  // actually broken.
+  // Drop our reference to the parser to get rid of a circular
+  // reference.
+  RefPtr<nsParserBase> kungFuDeathGrip(mParser.forget());
+
+  if (mDynamicLowerValue) {
+    // Reset the performance hint which was set to FALSE
+    // when mDynamicLowerValue was set.
+    FavorPerformanceHint(true, 0);
+  }
+
+  if (!mRunsToCompletion) {
+    mDocument->UnblockOnload(true);
+  }
+}
+
+bool
+nsContentSink::IsScriptExecutingImpl()
+{
+  return !!mScriptLoader->GetCurrentScript();
+}
+
+nsresult
+nsContentSink::WillParseImpl(void)
+{
+  if (mRunsToCompletion || !mDocument) {
+    return NS_OK;
+  }
+
+  nsIPresShell *shell = mDocument->GetShell();
+  if (!shell) {
+    return NS_OK;
+  }
+
+  uint32_t currentTime = PR_IntervalToMicroseconds(PR_IntervalNow());
+
+  if (sEnablePerfMode == 0) {
+    nsViewManager* vm = shell->GetViewManager();
+    NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
+    uint32_t lastEventTime;
+    vm->GetLastUserEventTime(lastEventTime);
+
+    bool newDynLower =
+      mDocument->IsInBackgroundWindow() ||
+      ((currentTime - mBeginLoadTime) > uint32_t(sInitialPerfTime) &&
+       (currentTime - lastEventTime) < uint32_t(sInteractiveTime));
+    
+    if (mDynamicLowerValue != newDynLower) {
+      FavorPerformanceHint(!newDynLower, 0);
+      mDynamicLowerValue = newDynLower;
+    }
+  }
+  
+  mDeflectedCount = 0;
+  mHasPendingEvent = false;
+
+  mCurrentParseEndTime = currentTime +
+    (mDynamicLowerValue ? sInteractiveParseTime : sPerfParseTime);
+
+  return NS_OK;
+}
+
+void
+nsContentSink::WillBuildModelImpl()
+{
+  if (!mRunsToCompletion) {
+    mDocument->BlockOnload();
+
+    mBeginLoadTime = PR_IntervalToMicroseconds(PR_IntervalNow());
+  }
+
+  mDocument->ResetScrolledToRefAlready();
+
+  if (mProcessLinkHeaderEvent.get()) {
+    mProcessLinkHeaderEvent.Revoke();
+
+    DoProcessLinkHeader();
+  }
+}
+
+/* static */
+void
+nsContentSink::NotifyDocElementCreated(nsIDocument* aDoc)
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService) {
+    nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(aDoc);
+    observerService->
+      NotifyObservers(domDoc, "document-element-inserted",
+                      EmptyString().get());
+  }
+
+  nsContentUtils::DispatchChromeEvent(aDoc, aDoc,
+                                      NS_LITERAL_STRING("DOMDocElementInserted"),
+                                      true, false);
+}