michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
michael@0:  * vim: ft=cpp tw=78 sw=2 et ts=2
michael@0:  *
michael@0:  * This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
michael@0:  *
michael@0:  * This Original Code has been modified by IBM Corporation.
michael@0:  * Modifications made by IBM described herein are Copyright (c)
michael@0:  * International Business Machines Corporation, 2000.  Modifications
michael@0:  * to Mozilla code or documentation identified per MPL Section 3.3
michael@0:  *
michael@0:  * Date             Modified by     Description of modification
michael@0:  * 04/20/2000       IBM Corp.      OS/2 VisualAge build.
michael@0:  */
michael@0: 
michael@0: /* loading of CSS style sheets using the network APIs */
michael@0: 
michael@0: #include "mozilla/ArrayUtils.h"
michael@0: #include "mozilla/MemoryReporting.h"
michael@0: 
michael@0: #include "mozilla/css/Loader.h"
michael@0: #include "nsIRunnable.h"
michael@0: #include "nsIUnicharStreamLoader.h"
michael@0: #include "nsSyncLoadService.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsString.h"
michael@0: #include "nsIContent.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIDOMNode.h"
michael@0: #include "nsIDOMDocument.h"
michael@0: #include "nsIURI.h"
michael@0: #include "nsNetUtil.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsIScriptSecurityManager.h"
michael@0: #include "nsContentPolicyUtils.h"
michael@0: #include "nsIHttpChannel.h"
michael@0: #include "nsIHttpChannelInternal.h"
michael@0: #include "nsIScriptError.h"
michael@0: #include "nsMimeTypes.h"
michael@0: #include "nsCSSStyleSheet.h"
michael@0: #include "nsIStyleSheetLinkingElement.h"
michael@0: #include "nsICSSLoaderObserver.h"
michael@0: #include "nsCSSParser.h"
michael@0: #include "mozilla/css/ImportRule.h"
michael@0: #include "nsThreadUtils.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsIThreadInternal.h"
michael@0: #include "nsCrossSiteListenerProxy.h"
michael@0: #include "nsINetworkSeer.h"
michael@0: #include "mozilla/dom/ShadowRoot.h"
michael@0: #include "mozilla/dom/URL.h"
michael@0: 
michael@0: #ifdef MOZ_XUL
michael@0: #include "nsXULPrototypeCache.h"
michael@0: #endif
michael@0: 
michael@0: #include "nsIMediaList.h"
michael@0: #include "nsIDOMStyleSheet.h"
michael@0: #include "nsError.h"
michael@0: 
michael@0: #include "nsIChannelPolicy.h"
michael@0: #include "nsIContentSecurityPolicy.h"
michael@0: #include "nsCycleCollectionParticipant.h"
michael@0: 
michael@0: #include "mozilla/dom/EncodingUtils.h"
michael@0: using mozilla::dom::EncodingUtils;
michael@0: 
michael@0: using namespace mozilla::dom;
michael@0: 
michael@0: /**
michael@0:  * OVERALL ARCHITECTURE
michael@0:  *
michael@0:  * The CSS Loader gets requests to load various sorts of style sheets:
michael@0:  * inline style from <style> elements, linked style, @import-ed child
michael@0:  * sheets, non-document sheets.  The loader handles the following tasks:
michael@0:  *
michael@0:  * 1) Checking whether the load is allowed: CheckLoadAllowed()
michael@0:  * 2) Creation of the actual style sheet objects: CreateSheet()
michael@0:  * 3) setting of the right media, title, enabled state, etc on the
michael@0:  *    sheet: PrepareSheet()
michael@0:  * 4) Insertion of the sheet in the proper cascade order:
michael@0:  *    InsertSheetInDoc() and InsertChildSheet()
michael@0:  * 5) Load of the sheet: LoadSheet()
michael@0:  * 6) Parsing of the sheet: ParseSheet()
michael@0:  * 7) Cleanup: SheetComplete()
michael@0:  *
michael@0:  * The detailed documentation for these functions is found with the
michael@0:  * function implementations.
michael@0:  *
michael@0:  * The following helper object is used:
michael@0:  *    SheetLoadData -- a small class that is used to store all the
michael@0:  *                     information needed for the loading of a sheet;
michael@0:  *                     this class handles listening for the stream
michael@0:  *                     loader completion and also handles charset
michael@0:  *                     determination.
michael@0:  */
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace css {
michael@0: 
michael@0: /*********************************************
michael@0:  * Data needed to properly load a stylesheet *
michael@0:  *********************************************/
michael@0: 
michael@0: class SheetLoadData : public nsIRunnable,
michael@0:                       public nsIUnicharStreamLoaderObserver,
michael@0:                       public nsIThreadObserver
michael@0: {
michael@0: public:
michael@0:   virtual ~SheetLoadData(void);
michael@0:   // Data for loading a sheet linked from a document
michael@0:   SheetLoadData(Loader* aLoader,
michael@0:                 const nsSubstring& aTitle,
michael@0:                 nsIURI* aURI,
michael@0:                 nsCSSStyleSheet* aSheet,
michael@0:                 nsIStyleSheetLinkingElement* aOwningElement,
michael@0:                 bool aIsAlternate,
michael@0:                 nsICSSLoaderObserver* aObserver,
michael@0:                 nsIPrincipal* aLoaderPrincipal);
michael@0: 
michael@0:   // Data for loading a sheet linked from an @import rule
michael@0:   SheetLoadData(Loader* aLoader,
michael@0:                 nsIURI* aURI,
michael@0:                 nsCSSStyleSheet* aSheet,
michael@0:                 SheetLoadData* aParentData,
michael@0:                 nsICSSLoaderObserver* aObserver,
michael@0:                 nsIPrincipal* aLoaderPrincipal);
michael@0: 
michael@0:   // Data for loading a non-document sheet
michael@0:   SheetLoadData(Loader* aLoader,
michael@0:                 nsIURI* aURI,
michael@0:                 nsCSSStyleSheet* aSheet,
michael@0:                 bool aSyncLoad,
michael@0:                 bool aAllowUnsafeRules,
michael@0:                 bool aUseSystemPrincipal,
michael@0:                 const nsCString& aCharset,
michael@0:                 nsICSSLoaderObserver* aObserver,
michael@0:                 nsIPrincipal* aLoaderPrincipal);
michael@0: 
michael@0:   already_AddRefed<nsIURI> GetReferrerURI();
michael@0: 
michael@0:   void ScheduleLoadEventIfNeeded(nsresult aStatus);
michael@0: 
michael@0:   NS_DECL_ISUPPORTS
michael@0:   NS_DECL_NSIRUNNABLE
michael@0:   NS_DECL_NSITHREADOBSERVER
michael@0:   NS_DECL_NSIUNICHARSTREAMLOADEROBSERVER
michael@0: 
michael@0:   // Hold a ref to the CSSLoader so we can call back to it to let it
michael@0:   // know the load finished
michael@0:   Loader*                    mLoader; // strong ref
michael@0: 
michael@0:   // Title needed to pull datas out of the pending datas table when
michael@0:   // the preferred title is changed
michael@0:   nsString                   mTitle;
michael@0: 
michael@0:   // Charset we decided to use for the sheet
michael@0:   nsCString                  mCharset;
michael@0: 
michael@0:   // URI we're loading.  Null for inline sheets
michael@0:   nsCOMPtr<nsIURI>           mURI;
michael@0: 
michael@0:   // Should be 1 for non-inline sheets.
michael@0:   uint32_t                   mLineNumber;
michael@0: 
michael@0:   // The sheet we're loading data for
michael@0:   nsRefPtr<nsCSSStyleSheet>  mSheet;
michael@0: 
michael@0:   // Linked list of datas for the same URI as us
michael@0:   SheetLoadData*             mNext;  // strong ref
michael@0: 
michael@0:   // Load data for the sheet that @import-ed us if we were @import-ed
michael@0:   // during the parse
michael@0:   SheetLoadData*             mParentData;  // strong ref
michael@0: 
michael@0:   // Number of sheets we @import-ed that are still loading
michael@0:   uint32_t                   mPendingChildren;
michael@0: 
michael@0:   // mSyncLoad is true when the load needs to be synchronous -- right
michael@0:   // now only for LoadSheetSync and children of sync loads.
michael@0:   bool                       mSyncLoad : 1;
michael@0: 
michael@0:   // mIsNonDocumentSheet is true if the load was triggered by LoadSheetSync or
michael@0:   // LoadSheet or an @import from such a sheet.  Non-document sheet loads can
michael@0:   // proceed even if we have no document.
michael@0:   bool                       mIsNonDocumentSheet : 1;
michael@0: 
michael@0:   // mIsLoading is true from the moment we are placed in the loader's
michael@0:   // "loading datas" table (right after the async channel is opened)
michael@0:   // to the moment we are removed from said table (due to the load
michael@0:   // completing or being cancelled).
michael@0:   bool                       mIsLoading : 1;
michael@0: 
michael@0:   // mIsCancelled is set to true when a sheet load is stopped by
michael@0:   // Stop() or StopLoadingSheet() (which was removed in Bug 556446).
michael@0:   // SheetLoadData::OnStreamComplete() checks this to avoid parsing
michael@0:   // sheets that have been cancelled and such.
michael@0:   bool                       mIsCancelled : 1;
michael@0: 
michael@0:   // mMustNotify is true if the load data is being loaded async and
michael@0:   // the original function call that started the load has returned.
michael@0:   // This applies only to observer notifications; load/error events
michael@0:   // are fired for any SheetLoadData that has a non-null
michael@0:   // mOwningElement.
michael@0:   bool                       mMustNotify : 1;
michael@0: 
michael@0:   // mWasAlternate is true if the sheet was an alternate when the load data was
michael@0:   // created.
michael@0:   bool                       mWasAlternate : 1;
michael@0: 
michael@0:   // mAllowUnsafeRules is true if we should allow unsafe rules to be parsed
michael@0:   // in the loaded sheet.
michael@0:   bool                       mAllowUnsafeRules : 1;
michael@0: 
michael@0:   // mUseSystemPrincipal is true if the system principal should be used for
michael@0:   // this sheet, no matter what the channel principal is.  Only true for sync
michael@0:   // loads.
michael@0:   bool                       mUseSystemPrincipal : 1;
michael@0: 
michael@0:   // If true, this SheetLoadData is being used as a way to handle
michael@0:   // async observer notification for an already-complete sheet.
michael@0:   bool                       mSheetAlreadyComplete : 1;
michael@0: 
michael@0:   // This is the element that imported the sheet.  Needed to get the
michael@0:   // charset set on it and to fire load/error events.
michael@0:   nsCOMPtr<nsIStyleSheetLinkingElement> mOwningElement;
michael@0: 
michael@0:   // The observer that wishes to be notified of load completion
michael@0:   nsCOMPtr<nsICSSLoaderObserver>        mObserver;
michael@0: 
michael@0:   // The principal that identifies who started loading us.
michael@0:   nsCOMPtr<nsIPrincipal>                mLoaderPrincipal;
michael@0: 
michael@0:   // The charset to use if the transport and sheet don't indicate one.
michael@0:   // May be empty.  Must be empty if mOwningElement is non-null.
michael@0:   nsCString                             mCharsetHint;
michael@0: 
michael@0:   // The status our load ended up with; this determines whether we
michael@0:   // should fire error events or load events.  This gets initialized
michael@0:   // by ScheduleLoadEventIfNeeded, and is only used after that has
michael@0:   // been called.
michael@0:   nsresult                              mStatus;
michael@0: 
michael@0: private:
michael@0:   void FireLoadEvent(nsIThreadInternal* aThread);
michael@0: };
michael@0: 
michael@0: #ifdef MOZ_LOGGING
michael@0: // #define FORCE_PR_LOG /* Allow logging in the release build */
michael@0: #endif /* MOZ_LOGGING */
michael@0: #include "prlog.h"
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: static PRLogModuleInfo *
michael@0: GetLoaderLog()
michael@0: {
michael@0:   static PRLogModuleInfo *sLog;
michael@0:   if (!sLog)
michael@0:     sLog = PR_NewLogModule("nsCSSLoader");
michael@0:   return sLog;
michael@0: }
michael@0: #endif /* PR_LOGGING */
michael@0: 
michael@0: #define LOG_FORCE(args) PR_LOG(GetLoaderLog(), PR_LOG_ALWAYS, args)
michael@0: #define LOG_ERROR(args) PR_LOG(GetLoaderLog(), PR_LOG_ERROR, args)
michael@0: #define LOG_WARN(args) PR_LOG(GetLoaderLog(), PR_LOG_WARNING, args)
michael@0: #define LOG_DEBUG(args) PR_LOG(GetLoaderLog(), PR_LOG_DEBUG, args)
michael@0: #define LOG(args) LOG_DEBUG(args)
michael@0: 
michael@0: #define LOG_FORCE_ENABLED() PR_LOG_TEST(GetLoaderLog(), PR_LOG_ALWAYS)
michael@0: #define LOG_ERROR_ENABLED() PR_LOG_TEST(GetLoaderLog(), PR_LOG_ERROR)
michael@0: #define LOG_WARN_ENABLED() PR_LOG_TEST(GetLoaderLog(), PR_LOG_WARNING)
michael@0: #define LOG_DEBUG_ENABLED() PR_LOG_TEST(GetLoaderLog(), PR_LOG_DEBUG)
michael@0: #define LOG_ENABLED() LOG_DEBUG_ENABLED()
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: #define LOG_URI(format, uri)                        \
michael@0:   PR_BEGIN_MACRO                                    \
michael@0:     NS_ASSERTION(uri, "Logging null uri");          \
michael@0:     if (LOG_ENABLED()) {                            \
michael@0:       nsAutoCString _logURISpec;                    \
michael@0:       uri->GetSpec(_logURISpec);                    \
michael@0:       LOG((format, _logURISpec.get()));             \
michael@0:     }                                               \
michael@0:   PR_END_MACRO
michael@0: #else // PR_LOGGING
michael@0: #define LOG_URI(format, uri)
michael@0: #endif // PR_LOGGING
michael@0: 
michael@0: // And some convenience strings...
michael@0: #ifdef PR_LOGGING
michael@0: static const char* const gStateStrings[] = {
michael@0:   "eSheetStateUnknown",
michael@0:   "eSheetNeedsParser",
michael@0:   "eSheetPending",
michael@0:   "eSheetLoading",
michael@0:   "eSheetComplete"
michael@0: };
michael@0: #endif
michael@0: 
michael@0: /********************************
michael@0:  * SheetLoadData implementation *
michael@0:  ********************************/
michael@0: NS_IMPL_ISUPPORTS(SheetLoadData, nsIUnicharStreamLoaderObserver, nsIRunnable,
michael@0:                   nsIThreadObserver)
michael@0: 
michael@0: SheetLoadData::SheetLoadData(Loader* aLoader,
michael@0:                              const nsSubstring& aTitle,
michael@0:                              nsIURI* aURI,
michael@0:                              nsCSSStyleSheet* aSheet,
michael@0:                              nsIStyleSheetLinkingElement* aOwningElement,
michael@0:                              bool aIsAlternate,
michael@0:                              nsICSSLoaderObserver* aObserver,
michael@0:                              nsIPrincipal* aLoaderPrincipal)
michael@0:   : mLoader(aLoader),
michael@0:     mTitle(aTitle),
michael@0:     mURI(aURI),
michael@0:     mLineNumber(1),
michael@0:     mSheet(aSheet),
michael@0:     mNext(nullptr),
michael@0:     mParentData(nullptr),
michael@0:     mPendingChildren(0),
michael@0:     mSyncLoad(false),
michael@0:     mIsNonDocumentSheet(false),
michael@0:     mIsLoading(false),
michael@0:     mIsCancelled(false),
michael@0:     mMustNotify(false),
michael@0:     mWasAlternate(aIsAlternate),
michael@0:     mAllowUnsafeRules(false),
michael@0:     mUseSystemPrincipal(false),
michael@0:     mSheetAlreadyComplete(false),
michael@0:     mOwningElement(aOwningElement),
michael@0:     mObserver(aObserver),
michael@0:     mLoaderPrincipal(aLoaderPrincipal)
michael@0: {
michael@0:   NS_PRECONDITION(mLoader, "Must have a loader!");
michael@0:   NS_ADDREF(mLoader);
michael@0: }
michael@0: 
michael@0: SheetLoadData::SheetLoadData(Loader* aLoader,
michael@0:                              nsIURI* aURI,
michael@0:                              nsCSSStyleSheet* aSheet,
michael@0:                              SheetLoadData* aParentData,
michael@0:                              nsICSSLoaderObserver* aObserver,
michael@0:                              nsIPrincipal* aLoaderPrincipal)
michael@0:   : mLoader(aLoader),
michael@0:     mURI(aURI),
michael@0:     mLineNumber(1),
michael@0:     mSheet(aSheet),
michael@0:     mNext(nullptr),
michael@0:     mParentData(aParentData),
michael@0:     mPendingChildren(0),
michael@0:     mSyncLoad(false),
michael@0:     mIsNonDocumentSheet(false),
michael@0:     mIsLoading(false),
michael@0:     mIsCancelled(false),
michael@0:     mMustNotify(false),
michael@0:     mWasAlternate(false),
michael@0:     mAllowUnsafeRules(false),
michael@0:     mUseSystemPrincipal(false),
michael@0:     mSheetAlreadyComplete(false),
michael@0:     mOwningElement(nullptr),
michael@0:     mObserver(aObserver),
michael@0:     mLoaderPrincipal(aLoaderPrincipal)
michael@0: {
michael@0:   NS_PRECONDITION(mLoader, "Must have a loader!");
michael@0:   NS_ADDREF(mLoader);
michael@0:   if (mParentData) {
michael@0:     NS_ADDREF(mParentData);
michael@0:     mSyncLoad = mParentData->mSyncLoad;
michael@0:     mIsNonDocumentSheet = mParentData->mIsNonDocumentSheet;
michael@0:     mAllowUnsafeRules = mParentData->mAllowUnsafeRules;
michael@0:     mUseSystemPrincipal = mParentData->mUseSystemPrincipal;
michael@0:     ++(mParentData->mPendingChildren);
michael@0:   }
michael@0: 
michael@0:   NS_POSTCONDITION(!mUseSystemPrincipal || mSyncLoad,
michael@0:                    "Shouldn't use system principal for async loads");
michael@0: }
michael@0: 
michael@0: SheetLoadData::SheetLoadData(Loader* aLoader,
michael@0:                              nsIURI* aURI,
michael@0:                              nsCSSStyleSheet* aSheet,
michael@0:                              bool aSyncLoad,
michael@0:                              bool aAllowUnsafeRules,
michael@0:                              bool aUseSystemPrincipal,
michael@0:                              const nsCString& aCharset,
michael@0:                              nsICSSLoaderObserver* aObserver,
michael@0:                              nsIPrincipal* aLoaderPrincipal)
michael@0:   : mLoader(aLoader),
michael@0:     mURI(aURI),
michael@0:     mLineNumber(1),
michael@0:     mSheet(aSheet),
michael@0:     mNext(nullptr),
michael@0:     mParentData(nullptr),
michael@0:     mPendingChildren(0),
michael@0:     mSyncLoad(aSyncLoad),
michael@0:     mIsNonDocumentSheet(true),
michael@0:     mIsLoading(false),
michael@0:     mIsCancelled(false),
michael@0:     mMustNotify(false),
michael@0:     mWasAlternate(false),
michael@0:     mAllowUnsafeRules(aAllowUnsafeRules),
michael@0:     mUseSystemPrincipal(aUseSystemPrincipal),
michael@0:     mSheetAlreadyComplete(false),
michael@0:     mOwningElement(nullptr),
michael@0:     mObserver(aObserver),
michael@0:     mLoaderPrincipal(aLoaderPrincipal),
michael@0:     mCharsetHint(aCharset)
michael@0: {
michael@0:   NS_PRECONDITION(mLoader, "Must have a loader!");
michael@0:   NS_ADDREF(mLoader);
michael@0: 
michael@0:   NS_POSTCONDITION(!mUseSystemPrincipal || mSyncLoad,
michael@0:                    "Shouldn't use system principal for async loads");
michael@0: }
michael@0: 
michael@0: SheetLoadData::~SheetLoadData()
michael@0: {
michael@0:   NS_RELEASE(mLoader);
michael@0:   NS_IF_RELEASE(mParentData);
michael@0:   NS_IF_RELEASE(mNext);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::Run()
michael@0: {
michael@0:   mLoader->HandleLoadEvent(this);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::OnDispatchedEvent(nsIThreadInternal* aThread)
michael@0: {
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::OnProcessNextEvent(nsIThreadInternal* aThread,
michael@0:                                   bool aMayWait,
michael@0:                                   uint32_t aRecursionDepth)
michael@0: {
michael@0:   // We want to fire our load even before or after event processing,
michael@0:   // whichever comes first.
michael@0:   FireLoadEvent(aThread);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::AfterProcessNextEvent(nsIThreadInternal* aThread,
michael@0:                                      uint32_t aRecursionDepth,
michael@0:                                      bool aEventWasProcessed)
michael@0: {
michael@0:   // We want to fire our load even before or after event processing,
michael@0:   // whichever comes first.
michael@0:   FireLoadEvent(aThread);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: SheetLoadData::FireLoadEvent(nsIThreadInternal* aThread)
michael@0: {
michael@0:   
michael@0:   // First remove ourselves as a thread observer.  But we need to keep
michael@0:   // ourselves alive while doing that!
michael@0:   nsRefPtr<SheetLoadData> kungFuDeathGrip(this);
michael@0:   aThread->RemoveObserver(this);
michael@0: 
michael@0:   // Now fire the event
michael@0:   nsCOMPtr<nsINode> node = do_QueryInterface(mOwningElement);
michael@0:   NS_ASSERTION(node, "How did that happen???");
michael@0: 
michael@0:   nsContentUtils::DispatchTrustedEvent(node->OwnerDoc(),
michael@0:                                        node,
michael@0:                                        NS_SUCCEEDED(mStatus) ?
michael@0:                                          NS_LITERAL_STRING("load") :
michael@0:                                          NS_LITERAL_STRING("error"),
michael@0:                                        false, false);
michael@0: 
michael@0:   // And unblock onload
michael@0:   if (mLoader->mDocument) {
michael@0:     mLoader->mDocument->UnblockOnload(true);
michael@0:   }  
michael@0: }
michael@0: 
michael@0: void
michael@0: SheetLoadData::ScheduleLoadEventIfNeeded(nsresult aStatus)
michael@0: {
michael@0:   if (!mOwningElement) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   mStatus = aStatus;
michael@0: 
michael@0:   nsCOMPtr<nsIThread> thread = do_GetMainThread();
michael@0:   nsCOMPtr<nsIThreadInternal> internalThread = do_QueryInterface(thread);
michael@0:   if (NS_SUCCEEDED(internalThread->AddObserver(this))) {
michael@0:     // Make sure to block onload here
michael@0:     if (mLoader->mDocument) {
michael@0:       mLoader->mDocument->BlockOnload();
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: /*************************
michael@0:  * Loader Implementation *
michael@0:  *************************/
michael@0: 
michael@0: Loader::Loader(void)
michael@0:   : mDocument(nullptr)
michael@0:   , mDatasToNotifyOn(0)
michael@0:   , mCompatMode(eCompatibility_FullStandards)
michael@0:   , mEnabled(true)
michael@0: #ifdef DEBUG
michael@0:   , mSyncCallback(false)
michael@0: #endif
michael@0: {
michael@0: }
michael@0: 
michael@0: Loader::Loader(nsIDocument* aDocument)
michael@0:   : mDocument(aDocument)
michael@0:   , mDatasToNotifyOn(0)
michael@0:   , mCompatMode(eCompatibility_FullStandards)
michael@0:   , mEnabled(true)
michael@0: #ifdef DEBUG
michael@0:   , mSyncCallback(false)
michael@0: #endif
michael@0: {
michael@0:   // We can just use the preferred set, since there are no sheets in the
michael@0:   // document yet (if there are, how did they get there? _we_ load the sheets!)
michael@0:   // and hence the selected set makes no sense at this time.
michael@0:   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
michael@0:   if (domDoc) {
michael@0:     domDoc->GetPreferredStyleSheetSet(mPreferredSheet);
michael@0:   }
michael@0: }
michael@0: 
michael@0: Loader::~Loader()
michael@0: {
michael@0:   NS_ASSERTION(!mSheets || mSheets->mLoadingDatas.Count() == 0,
michael@0:                "How did we get destroyed when there are loading data?");
michael@0:   NS_ASSERTION(!mSheets || mSheets->mPendingDatas.Count() == 0,
michael@0:                "How did we get destroyed when there are pending data?");
michael@0:   // Note: no real need to revoke our stylesheet loaded events -- they
michael@0:   // hold strong references to us, so if we're going away that means
michael@0:   // they're all done.
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::DropDocumentReference(void)
michael@0: {
michael@0:   mDocument = nullptr;
michael@0:   // Flush out pending datas just so we don't leak by accident.  These
michael@0:   // loads should short-circuit through the mDocument check in
michael@0:   // LoadSheet and just end up in SheetComplete immediately
michael@0:   if (mSheets) {
michael@0:     StartAlternateLoads();
michael@0:   }
michael@0: }
michael@0: 
michael@0: static PLDHashOperator
michael@0: CollectNonAlternates(URIPrincipalAndCORSModeHashKey *aKey,
michael@0:                      SheetLoadData* &aData,
michael@0:                      void* aClosure)
michael@0: {
michael@0:   NS_PRECONDITION(aData, "Must have a data");
michael@0:   NS_PRECONDITION(aClosure, "Must have an array");
michael@0: 
michael@0:   // Note that we don't want to affect what the selected style set is,
michael@0:   // so use true for aHasAlternateRel.
michael@0:   if (aData->mLoader->IsAlternate(aData->mTitle, true)) {
michael@0:     return PL_DHASH_NEXT;
michael@0:   }
michael@0: 
michael@0:   static_cast<Loader::LoadDataArray*>(aClosure)->AppendElement(aData);
michael@0:   return PL_DHASH_REMOVE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::SetPreferredSheet(const nsAString& aTitle)
michael@0: {
michael@0: #ifdef DEBUG
michael@0:   nsCOMPtr<nsIDOMDocument> doc = do_QueryInterface(mDocument);
michael@0:   if (doc) {
michael@0:     nsAutoString currentPreferred;
michael@0:     doc->GetLastStyleSheetSet(currentPreferred);
michael@0:     if (DOMStringIsNull(currentPreferred)) {
michael@0:       doc->GetPreferredStyleSheetSet(currentPreferred);
michael@0:     }
michael@0:     NS_ASSERTION(currentPreferred.Equals(aTitle),
michael@0:                  "Unexpected argument to SetPreferredSheet");
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   mPreferredSheet = aTitle;
michael@0: 
michael@0:   // start any pending alternates that aren't alternates anymore
michael@0:   if (mSheets) {
michael@0:     LoadDataArray arr(mSheets->mPendingDatas.Count());
michael@0:     mSheets->mPendingDatas.Enumerate(CollectNonAlternates, &arr);
michael@0: 
michael@0:     mDatasToNotifyOn += arr.Length();
michael@0:     for (uint32_t i = 0; i < arr.Length(); ++i) {
michael@0:       --mDatasToNotifyOn;
michael@0:       LoadSheet(arr[i], eSheetNeedsParser);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: static const char kCharsetSym[] = "@charset \"";
michael@0: 
michael@0: static bool GetCharsetFromData(const char* aStyleSheetData,
michael@0:                                uint32_t aDataLength,
michael@0:                                nsACString& aCharset)
michael@0: {
michael@0:   aCharset.Truncate();
michael@0:   if (aDataLength <= sizeof(kCharsetSym) - 1)
michael@0:     return false;
michael@0: 
michael@0:   if (strncmp(aStyleSheetData,
michael@0:               kCharsetSym,
michael@0:               sizeof(kCharsetSym) - 1)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   for (uint32_t i = sizeof(kCharsetSym) - 1; i < aDataLength; ++i) {
michael@0:     char c = aStyleSheetData[i];
michael@0:     if (c == '"') {
michael@0:       ++i;
michael@0:       if (i < aDataLength && aStyleSheetData[i] == ';') {
michael@0:         return true;
michael@0:       }
michael@0:       // fail
michael@0:       break;
michael@0:     }
michael@0:     aCharset.Append(c);
michael@0:   }
michael@0: 
michael@0:   // Did not see end quote or semicolon
michael@0:   aCharset.Truncate();
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::OnDetermineCharset(nsIUnicharStreamLoader* aLoader,
michael@0:                                   nsISupports* aContext,
michael@0:                                   nsACString const& aSegment,
michael@0:                                   nsACString& aCharset)
michael@0: {
michael@0:   NS_PRECONDITION(!mOwningElement || mCharsetHint.IsEmpty(),
michael@0:                   "Can't have element _and_ charset hint");
michael@0: 
michael@0:   LOG_URI("SheetLoadData::OnDetermineCharset for '%s'", mURI);
michael@0: 
michael@0:   // The precedence is (per CSS3 Syntax 2012-11-08 ED):
michael@0:   // BOM
michael@0:   // Channel
michael@0:   // @charset rule
michael@0:   // charset attribute on the referrer
michael@0:   // encoding of the referrer
michael@0:   // UTF-8
michael@0: 
michael@0:   aCharset.Truncate();
michael@0: 
michael@0:   if (nsContentUtils::CheckForBOM((const unsigned char*)aSegment.BeginReading(),
michael@0:                                   aSegment.Length(),
michael@0:                                   aCharset)) {
michael@0:     // aCharset is now either "UTF-16BE", "UTF-16BE" or "UTF-8"
michael@0:     // which will swallow the BOM.
michael@0:     mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:     LOG(("  Setting from BOM to: %s", PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIChannel> channel;
michael@0:   nsAutoCString specified;
michael@0:   aLoader->GetChannel(getter_AddRefs(channel));
michael@0:   if (channel) {
michael@0:     channel->GetContentCharset(specified);
michael@0:     if (EncodingUtils::FindEncodingForLabel(specified, aCharset)) {
michael@0:       mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:       LOG(("  Setting from HTTP to: %s", PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (GetCharsetFromData(aSegment.BeginReading(),
michael@0:                          aSegment.Length(),
michael@0:                          specified)) {
michael@0:     if (EncodingUtils::FindEncodingForLabel(specified, aCharset)) {
michael@0:       // FindEncodingForLabel currently never returns UTF-16LE but will
michael@0:       // probably change to never return UTF-16 instead, so check both here
michael@0:       // to avoid relying on the exact behavior.
michael@0:       if (aCharset.EqualsLiteral("UTF-16") ||
michael@0:           aCharset.EqualsLiteral("UTF-16BE") ||
michael@0:           aCharset.EqualsLiteral("UTF-16LE")) {
michael@0:         // Be consistent with HTML <meta> handling in face of impossibility.
michael@0:         // When the @charset rule itself evidently was not UTF-16-encoded,
michael@0:         // it saying UTF-16 has to be a lie.
michael@0:         aCharset.AssignLiteral("UTF-8");
michael@0:       }
michael@0:       mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:       LOG(("  Setting from @charset rule to: %s",
michael@0:           PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Now try the charset on the <link> or processing instruction
michael@0:   // that loaded us
michael@0:   if (mOwningElement) {
michael@0:     nsAutoString specified16;
michael@0:     mOwningElement->GetCharset(specified16);
michael@0:     if (EncodingUtils::FindEncodingForLabel(specified16, aCharset)) {
michael@0:       mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:       LOG(("  Setting from charset attribute to: %s",
michael@0:           PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // In the preload case, the value of the charset attribute on <link> comes
michael@0:   // in via mCharsetHint instead.
michael@0:   if (EncodingUtils::FindEncodingForLabel(mCharsetHint, aCharset)) {
michael@0:     mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:       LOG(("  Setting from charset attribute (preload case) to: %s",
michael@0:           PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Try charset from the parent stylesheet.
michael@0:   if (mParentData) {
michael@0:     aCharset = mParentData->mCharset;
michael@0:     if (!aCharset.IsEmpty()) {
michael@0:       mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:       LOG(("  Setting from parent sheet to: %s",
michael@0:           PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (mLoader->mDocument) {
michael@0:     // no useful data on charset.  Try the document charset.
michael@0:     aCharset = mLoader->mDocument->GetDocumentCharacterSet();
michael@0:     MOZ_ASSERT(!aCharset.IsEmpty());
michael@0:     mCharset.Assign(aCharset);
michael@0: #ifdef PR_LOGGING
michael@0:     LOG(("  Setting from document to: %s", PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   aCharset.AssignLiteral("UTF-8");
michael@0:   mCharset = aCharset;
michael@0: #ifdef PR_LOGGING
michael@0:   LOG(("  Setting from default to: %s", PromiseFlatCString(aCharset).get()));
michael@0: #endif
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIURI>
michael@0: SheetLoadData::GetReferrerURI()
michael@0: {
michael@0:   nsCOMPtr<nsIURI> uri;
michael@0:   if (mParentData)
michael@0:     uri = mParentData->mSheet->GetSheetURI();
michael@0:   if (!uri && mLoader->mDocument)
michael@0:     uri = mLoader->mDocument->GetDocumentURI();
michael@0:   return uri.forget();
michael@0: }
michael@0: 
michael@0: /*
michael@0:  * Here we need to check that the load did not give us an http error
michael@0:  * page and check the mimetype on the channel to make sure we're not
michael@0:  * loading non-text/css data in standards mode.
michael@0:  */
michael@0: NS_IMETHODIMP
michael@0: SheetLoadData::OnStreamComplete(nsIUnicharStreamLoader* aLoader,
michael@0:                                 nsISupports* aContext,
michael@0:                                 nsresult aStatus,
michael@0:                                 const nsAString& aBuffer)
michael@0: {
michael@0:   LOG(("SheetLoadData::OnStreamComplete"));
michael@0:   NS_ASSERTION(!mLoader->mSyncCallback, "Synchronous callback from necko");
michael@0: 
michael@0:   if (mIsCancelled) {
michael@0:     // Just return.  Don't call SheetComplete -- it's already been
michael@0:     // called and calling it again will lead to an extra NS_RELEASE on
michael@0:     // this data and a likely crash.
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (!mLoader->mDocument && !mIsNonDocumentSheet) {
michael@0:     // Sorry, we don't care about this load anymore
michael@0:     LOG_WARN(("  No document and not non-document sheet; dropping load"));
michael@0:     mLoader->SheetComplete(this, NS_BINDING_ABORTED);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (NS_FAILED(aStatus)) {
michael@0:     LOG_WARN(("  Load failed: status 0x%x", aStatus));
michael@0:     mLoader->SheetComplete(this, aStatus);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIChannel> channel;
michael@0:   nsresult result = aLoader->GetChannel(getter_AddRefs(channel));
michael@0:   if (NS_FAILED(result)) {
michael@0:     LOG_WARN(("  No channel from loader"));
michael@0:     mLoader->SheetComplete(this, result);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIURI> originalURI;
michael@0:   channel->GetOriginalURI(getter_AddRefs(originalURI));
michael@0: 
michael@0:   // If the channel's original URI is "chrome:", we want that, since
michael@0:   // the observer code in nsXULPrototypeCache depends on chrome stylesheets
michael@0:   // having a chrome URI.  (Whether or not chrome stylesheets come through
michael@0:   // this codepath seems nondeterministic.)
michael@0:   // Otherwise we want the potentially-HTTP-redirected URI.
michael@0:   nsCOMPtr<nsIURI> channelURI;
michael@0:   NS_GetFinalChannelURI(channel, getter_AddRefs(channelURI));
michael@0: 
michael@0:   if (!channelURI || !originalURI) {
michael@0:     NS_ERROR("Someone just violated the nsIRequest contract");
michael@0:     LOG_WARN(("  Channel without a URI.  Bad!"));
michael@0:     mLoader->SheetComplete(this, NS_ERROR_UNEXPECTED);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIPrincipal> principal;
michael@0:   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
michael@0:   result = NS_ERROR_NOT_AVAILABLE;
michael@0:   if (secMan) {  // Could be null if we already shut down
michael@0:     if (mUseSystemPrincipal) {
michael@0:       result = secMan->GetSystemPrincipal(getter_AddRefs(principal));
michael@0:     } else {
michael@0:       result = secMan->GetChannelPrincipal(channel, getter_AddRefs(principal));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (NS_FAILED(result)) {
michael@0:     LOG_WARN(("  Couldn't get principal"));
michael@0:     mLoader->SheetComplete(this, result);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   mSheet->SetPrincipal(principal);
michael@0: 
michael@0:   // If it's an HTTP channel, we want to make sure this is not an
michael@0:   // error document we got.
michael@0:   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
michael@0:   if (httpChannel) {
michael@0:     bool requestSucceeded;
michael@0:     result = httpChannel->GetRequestSucceeded(&requestSucceeded);
michael@0:     if (NS_SUCCEEDED(result) && !requestSucceeded) {
michael@0:       LOG(("  Load returned an error page"));
michael@0:       mLoader->SheetComplete(this, NS_ERROR_NOT_AVAILABLE);
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsAutoCString contentType;
michael@0:   if (channel) {
michael@0:     channel->GetContentType(contentType);
michael@0:   }
michael@0: 
michael@0:   // In standards mode, a style sheet must have one of these MIME
michael@0:   // types to be processed at all.  In quirks mode, we accept any
michael@0:   // MIME type, but only if the style sheet is same-origin with the
michael@0:   // requesting document or parent sheet.  See bug 524223.
michael@0: 
michael@0:   bool validType = contentType.EqualsLiteral("text/css") ||
michael@0:     contentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE) ||
michael@0:     contentType.IsEmpty();
michael@0: 
michael@0:   if (!validType) {
michael@0:     const char *errorMessage;
michael@0:     uint32_t errorFlag;
michael@0:     bool sameOrigin = true;
michael@0: 
michael@0:     if (mLoaderPrincipal) {
michael@0:       bool subsumed;
michael@0:       result = mLoaderPrincipal->Subsumes(principal, &subsumed);
michael@0:       if (NS_FAILED(result) || !subsumed) {
michael@0:         sameOrigin = false;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (sameOrigin && mLoader->mCompatMode == eCompatibility_NavQuirks) {
michael@0:       errorMessage = "MimeNotCssWarn";
michael@0:       errorFlag = nsIScriptError::warningFlag;
michael@0:     } else {
michael@0:       errorMessage = "MimeNotCss";
michael@0:       errorFlag = nsIScriptError::errorFlag;
michael@0:     }
michael@0: 
michael@0:     nsAutoCString spec;
michael@0:     channelURI->GetSpec(spec);
michael@0: 
michael@0:     const nsAFlatString& specUTF16 = NS_ConvertUTF8toUTF16(spec);
michael@0:     const nsAFlatString& ctypeUTF16 = NS_ConvertASCIItoUTF16(contentType);
michael@0:     const char16_t *strings[] = { specUTF16.get(), ctypeUTF16.get() };
michael@0: 
michael@0:     nsCOMPtr<nsIURI> referrer = GetReferrerURI();
michael@0:     nsContentUtils::ReportToConsole(errorFlag,
michael@0:                                     NS_LITERAL_CSTRING("CSS Loader"),
michael@0:                                     mLoader->mDocument,
michael@0:                                     nsContentUtils::eCSS_PROPERTIES,
michael@0:                                     errorMessage,
michael@0:                                     strings, ArrayLength(strings),
michael@0:                                     referrer);
michael@0: 
michael@0:     if (errorFlag == nsIScriptError::errorFlag) {
michael@0:       LOG_WARN(("  Ignoring sheet with improper MIME type %s",
michael@0:                 contentType.get()));
michael@0:       mLoader->SheetComplete(this, NS_ERROR_NOT_AVAILABLE);
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Enough to set the URIs on mSheet, since any sibling datas we have share
michael@0:   // the same mInner as mSheet and will thus get the same URI.
michael@0:   mSheet->SetURIs(channelURI, originalURI, channelURI);
michael@0: 
michael@0:   bool completed;
michael@0:   result = mLoader->ParseSheet(aBuffer, this, completed);
michael@0:   NS_ASSERTION(completed || !mSyncLoad, "sync load did not complete");
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Loader::IsAlternate(const nsAString& aTitle, bool aHasAlternateRel)
michael@0: {
michael@0:   // A sheet is alternate if it has a nonempty title that doesn't match the
michael@0:   // currently selected style set.  But if there _is_ no currently selected
michael@0:   // style set, the sheet wasn't marked as an alternate explicitly, and aTitle
michael@0:   // is nonempty, we should select the style set corresponding to aTitle, since
michael@0:   // that's a preferred sheet.
michael@0:   if (aTitle.IsEmpty()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (!aHasAlternateRel && mDocument && mPreferredSheet.IsEmpty()) {
michael@0:     // There's no preferred set yet, and we now have a sheet with a title.
michael@0:     // Make that be the preferred set.
michael@0:     mDocument->SetHeaderData(nsGkAtoms::headerDefaultStyle, aTitle);
michael@0:     // We're definitely not an alternate
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return !aTitle.Equals(mPreferredSheet);
michael@0: }
michael@0: 
michael@0: /* static */ PLDHashOperator
michael@0: Loader::RemoveEntriesWithURI(URIPrincipalAndCORSModeHashKey* aKey,
michael@0:                              nsRefPtr<nsCSSStyleSheet> &aSheet,
michael@0:                              void* aUserData)
michael@0: {
michael@0:   nsIURI* obsoleteURI = static_cast<nsIURI*>(aUserData);
michael@0:   nsIURI* sheetURI = aKey->GetURI();
michael@0:   bool areEqual;
michael@0:   nsresult rv = sheetURI->Equals(obsoleteURI, &areEqual);
michael@0:   if (NS_SUCCEEDED(rv) && areEqual) {
michael@0:     return PL_DHASH_REMOVE;
michael@0:   }
michael@0:   return PL_DHASH_NEXT;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::ObsoleteSheet(nsIURI* aURI)
michael@0: {
michael@0:   if (!mSheets) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   if (!aURI) {
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0:   mSheets->mCompleteSheets.Enumerate(RemoveEntriesWithURI, aURI);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * CheckLoadAllowed will return success if the load is allowed,
michael@0:  * failure otherwise.
michael@0:  *
michael@0:  * @param aSourcePrincipal the principal of the node or document or parent
michael@0:  *                         sheet loading the sheet
michael@0:  * @param aTargetURI the uri of the sheet to be loaded
michael@0:  * @param aContext the node owning the sheet.  This is the element or document
michael@0:  *                 owning the stylesheet (possibly indirectly, for child sheets)
michael@0:  */
michael@0: nsresult
michael@0: Loader::CheckLoadAllowed(nsIPrincipal* aSourcePrincipal,
michael@0:                          nsIURI* aTargetURI,
michael@0:                          nsISupports* aContext)
michael@0: {
michael@0:   LOG(("css::Loader::CheckLoadAllowed"));
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   if (aSourcePrincipal) {
michael@0:     // Check with the security manager
michael@0:     nsIScriptSecurityManager *secMan = nsContentUtils::GetSecurityManager();
michael@0:     rv =
michael@0:       secMan->CheckLoadURIWithPrincipal(aSourcePrincipal, aTargetURI,
michael@0:                                         nsIScriptSecurityManager::ALLOW_CHROME);
michael@0:     if (NS_FAILED(rv)) { // failure is normal here; don't warn
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     LOG(("  Passed security check"));
michael@0: 
michael@0:     // Check with content policy
michael@0: 
michael@0:     int16_t shouldLoad = nsIContentPolicy::ACCEPT;
michael@0:     rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_STYLESHEET,
michael@0:                                    aTargetURI,
michael@0:                                    aSourcePrincipal,
michael@0:                                    aContext,
michael@0:                                    NS_LITERAL_CSTRING("text/css"),
michael@0:                                    nullptr,                     //extra param
michael@0:                                    &shouldLoad,
michael@0:                                    nsContentUtils::GetContentPolicy(),
michael@0:                                    nsContentUtils::GetSecurityManager());
michael@0: 
michael@0:     if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
michael@0:       LOG(("  Load blocked by content policy"));
michael@0:       return NS_ERROR_CONTENT_BLOCKED;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * CreateSheet() creates an nsCSSStyleSheet object for the given URI,
michael@0:  * if any.  If there is no URI given, we just create a new style sheet
michael@0:  * object.  Otherwise, we check for an existing style sheet object for
michael@0:  * that uri in various caches and clone it if we find it.  Cloned
michael@0:  * sheets will have the title/media/enabled state of the sheet they
michael@0:  * are clones off; make sure to call PrepareSheet() on the result of
michael@0:  * CreateSheet().
michael@0:  */
michael@0: nsresult
michael@0: Loader::CreateSheet(nsIURI* aURI,
michael@0:                     nsIContent* aLinkingContent,
michael@0:                     nsIPrincipal* aLoaderPrincipal,
michael@0:                     CORSMode aCORSMode,
michael@0:                     bool aSyncLoad,
michael@0:                     bool aHasAlternateRel,
michael@0:                     const nsAString& aTitle,                       
michael@0:                     StyleSheetState& aSheetState,
michael@0:                     bool *aIsAlternate,
michael@0:                     nsCSSStyleSheet** aSheet)
michael@0: {
michael@0:   LOG(("css::Loader::CreateSheet"));
michael@0:   NS_PRECONDITION(aSheet, "Null out param!");
michael@0: 
michael@0:   if (!mSheets) {
michael@0:     mSheets = new Sheets();
michael@0:   }
michael@0: 
michael@0:   *aSheet = nullptr;
michael@0:   aSheetState = eSheetStateUnknown;
michael@0: 
michael@0:   // Check the alternate state before doing anything else, because it
michael@0:   // can mess with our hashtables.
michael@0:   *aIsAlternate = IsAlternate(aTitle, aHasAlternateRel);
michael@0: 
michael@0:   if (aURI) {
michael@0:     aSheetState = eSheetComplete;
michael@0:     nsRefPtr<nsCSSStyleSheet> sheet;
michael@0: 
michael@0:     // First, the XUL cache
michael@0: #ifdef MOZ_XUL
michael@0:     if (IsChromeURI(aURI)) {
michael@0:       nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
michael@0:       if (cache) {
michael@0:         if (cache->IsEnabled()) {
michael@0:           sheet = cache->GetStyleSheet(aURI);
michael@0:           LOG(("  From XUL cache: %p", sheet.get()));
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     bool fromCompleteSheets = false;
michael@0:     if (!sheet) {
michael@0:       // Then our per-document complete sheets.
michael@0:       URIPrincipalAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode);
michael@0: 
michael@0:       mSheets->mCompleteSheets.Get(&key, getter_AddRefs(sheet));
michael@0:       LOG(("  From completed: %p", sheet.get()));
michael@0: 
michael@0:       fromCompleteSheets = !!sheet;
michael@0:     }
michael@0: 
michael@0:     if (sheet) {
michael@0:       // This sheet came from the XUL cache or our per-document hashtable; it
michael@0:       // better be a complete sheet.
michael@0:       NS_ASSERTION(sheet->IsComplete(),
michael@0:                    "Sheet thinks it's not complete while we think it is");
michael@0: 
michael@0:       // Make sure it hasn't been modified; if it has, we can't use it
michael@0:       if (sheet->IsModified()) {
michael@0:         LOG(("  Not cloning completed sheet %p because it's been modified",
michael@0:              sheet.get()));
michael@0:         sheet = nullptr;
michael@0:         fromCompleteSheets = false;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Then loading sheets
michael@0:     if (!sheet && !aSyncLoad) {
michael@0:       aSheetState = eSheetLoading;
michael@0:       SheetLoadData* loadData = nullptr;
michael@0:       URIPrincipalAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode);
michael@0:       mSheets->mLoadingDatas.Get(&key, &loadData);
michael@0:       if (loadData) {
michael@0:         sheet = loadData->mSheet;
michael@0:         LOG(("  From loading: %p", sheet.get()));
michael@0: 
michael@0: #ifdef DEBUG
michael@0:         bool debugEqual;
michael@0:         NS_ASSERTION((!aLoaderPrincipal && !loadData->mLoaderPrincipal) ||
michael@0:                      (aLoaderPrincipal && loadData->mLoaderPrincipal &&
michael@0:                       NS_SUCCEEDED(aLoaderPrincipal->
michael@0:                                    Equals(loadData->mLoaderPrincipal,
michael@0:                                           &debugEqual)) && debugEqual),
michael@0:                      "Principals should be the same");
michael@0: #endif
michael@0:       }
michael@0: 
michael@0:       // Then alternate sheets
michael@0:       if (!sheet) {
michael@0:         aSheetState = eSheetPending;
michael@0:         loadData = nullptr;
michael@0:         mSheets->mPendingDatas.Get(&key, &loadData);
michael@0:         if (loadData) {
michael@0:           sheet = loadData->mSheet;
michael@0:           LOG(("  From pending: %p", sheet.get()));
michael@0: 
michael@0: #ifdef DEBUG
michael@0:           bool debugEqual;
michael@0:           NS_ASSERTION((!aLoaderPrincipal && !loadData->mLoaderPrincipal) ||
michael@0:                        (aLoaderPrincipal && loadData->mLoaderPrincipal &&
michael@0:                         NS_SUCCEEDED(aLoaderPrincipal->
michael@0:                                      Equals(loadData->mLoaderPrincipal,
michael@0:                                             &debugEqual)) && debugEqual),
michael@0:                        "Principals should be the same");
michael@0: #endif
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (sheet) {
michael@0:       // The sheet we have now should be either incomplete or unmodified
michael@0:       NS_ASSERTION(!sheet->IsModified() || !sheet->IsComplete(),
michael@0:                    "Unexpected modified complete sheet");
michael@0:       NS_ASSERTION(sheet->IsComplete() || aSheetState != eSheetComplete,
michael@0:                    "Sheet thinks it's not complete while we think it is");
michael@0: 
michael@0:       *aSheet = sheet->Clone(nullptr, nullptr, nullptr, nullptr).take();
michael@0:       if (*aSheet && fromCompleteSheets &&
michael@0:           !sheet->GetOwnerNode() && !sheet->GetParentSheet()) {
michael@0:         // The sheet we're cloning isn't actually referenced by
michael@0:         // anyone.  Replace it in the cache, so that if our CSSOM is
michael@0:         // later modified we don't end up with two copies of our inner
michael@0:         // hanging around.
michael@0:         URIPrincipalAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode);
michael@0:         NS_ASSERTION((*aSheet)->IsComplete(),
michael@0:                      "Should only be caching complete sheets");
michael@0:         mSheets->mCompleteSheets.Put(&key, *aSheet);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!*aSheet) {
michael@0:     aSheetState = eSheetNeedsParser;
michael@0:     nsIURI *sheetURI;
michael@0:     nsCOMPtr<nsIURI> baseURI;
michael@0:     nsIURI* originalURI;
michael@0:     if (!aURI) {
michael@0:       // Inline style.  Use the document's base URL so that @import in
michael@0:       // the inline sheet picks up the right base.
michael@0:       NS_ASSERTION(aLinkingContent, "Inline stylesheet without linking content?");
michael@0:       baseURI = aLinkingContent->GetBaseURI();
michael@0:       sheetURI = aLinkingContent->GetDocument()->GetDocumentURI();
michael@0:       originalURI = nullptr;
michael@0:     } else {
michael@0:       baseURI = aURI;
michael@0:       sheetURI = aURI;
michael@0:       originalURI = aURI;
michael@0:     }
michael@0: 
michael@0:     nsRefPtr<nsCSSStyleSheet> sheet = new nsCSSStyleSheet(aCORSMode);
michael@0:     sheet->SetURIs(sheetURI, originalURI, baseURI);
michael@0:     sheet.forget(aSheet);
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(*aSheet, "We should have a sheet by now!");
michael@0:   NS_ASSERTION(aSheetState != eSheetStateUnknown, "Have to set a state!");
michael@0:   LOG(("  State: %s", gStateStrings[aSheetState]));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * PrepareSheet() handles setting the media and title on the sheet, as
michael@0:  * well as setting the enabled state based on the title and whether
michael@0:  * the sheet had "alternate" in its rel.
michael@0:  */
michael@0: void
michael@0: Loader::PrepareSheet(nsCSSStyleSheet* aSheet,
michael@0:                      const nsSubstring& aTitle,
michael@0:                      const nsSubstring& aMediaString,
michael@0:                      nsMediaList* aMediaList,
michael@0:                      Element* aScopeElement,
michael@0:                      bool isAlternate)
michael@0: {
michael@0:   NS_PRECONDITION(aSheet, "Must have a sheet!");
michael@0: 
michael@0:   nsRefPtr<nsMediaList> mediaList(aMediaList);
michael@0: 
michael@0:   if (!aMediaString.IsEmpty()) {
michael@0:     NS_ASSERTION(!aMediaList,
michael@0:                  "must not provide both aMediaString and aMediaList");
michael@0:     mediaList = new nsMediaList();
michael@0: 
michael@0:     nsCSSParser mediumParser(this);
michael@0: 
michael@0:     // We have aMediaString only when linked from link elements, style
michael@0:     // elements, or PIs, so pass true.
michael@0:     mediumParser.ParseMediaList(aMediaString, nullptr, 0, mediaList, true);
michael@0:   }
michael@0: 
michael@0:   aSheet->SetMedia(mediaList);
michael@0: 
michael@0:   aSheet->SetTitle(aTitle);
michael@0:   aSheet->SetEnabled(! isAlternate);
michael@0:   aSheet->SetScopeElement(aScopeElement);
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * InsertSheetInDoc handles ordering of sheets in the document.  Here
michael@0:  * we have two types of sheets -- those with linking elements and
michael@0:  * those without.  The latter are loaded by Link: headers.
michael@0:  * The following constraints are observed:
michael@0:  * 1) Any sheet with a linking element comes after all sheets without
michael@0:  *    linking elements
michael@0:  * 2) Sheets without linking elements are inserted in the order in
michael@0:  *    which the inserting requests come in, since all of these are
michael@0:  *    inserted during header data processing in the content sink
michael@0:  * 3) Sheets with linking elements are ordered based on document order
michael@0:  *    as determined by CompareDocumentPosition.
michael@0:  */
michael@0: nsresult
michael@0: Loader::InsertSheetInDoc(nsCSSStyleSheet* aSheet,
michael@0:                          nsIContent* aLinkingContent,
michael@0:                          nsIDocument* aDocument)
michael@0: {
michael@0:   LOG(("css::Loader::InsertSheetInDoc"));
michael@0:   NS_PRECONDITION(aSheet, "Nothing to insert");
michael@0:   NS_PRECONDITION(aDocument, "Must have a document to insert into");
michael@0: 
michael@0:   // XXX Need to cancel pending sheet loads for this element, if any
michael@0: 
michael@0:   int32_t sheetCount = aDocument->GetNumberOfStyleSheets();
michael@0: 
michael@0:   /*
michael@0:    * Start the walk at the _end_ of the list, since in the typical
michael@0:    * case we'll just want to append anyway.  We want to break out of
michael@0:    * the loop when insertionPoint points to just before the index we
michael@0:    * want to insert at.  In other words, when we leave the loop
michael@0:    * insertionPoint is the index of the stylesheet that immediately
michael@0:    * precedes the one we're inserting.
michael@0:    */
michael@0:   int32_t insertionPoint;
michael@0:   for (insertionPoint = sheetCount - 1; insertionPoint >= 0; --insertionPoint) {
michael@0:     nsIStyleSheet *curSheet = aDocument->GetStyleSheetAt(insertionPoint);
michael@0:     NS_ASSERTION(curSheet, "There must be a sheet here!");
michael@0:     nsCOMPtr<nsIDOMStyleSheet> domSheet = do_QueryInterface(curSheet);
michael@0:     NS_ASSERTION(domSheet, "All the \"normal\" sheets implement nsIDOMStyleSheet");
michael@0:     nsCOMPtr<nsIDOMNode> sheetOwner;
michael@0:     domSheet->GetOwnerNode(getter_AddRefs(sheetOwner));
michael@0:     if (sheetOwner && !aLinkingContent) {
michael@0:       // Keep moving; all sheets with a sheetOwner come after all
michael@0:       // sheets without a linkingNode
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (!sheetOwner) {
michael@0:       // Aha!  The current sheet has no sheet owner, so we want to
michael@0:       // insert after it no matter whether we have a linkingNode
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsINode> sheetOwnerNode = do_QueryInterface(sheetOwner);
michael@0:     NS_ASSERTION(aLinkingContent != sheetOwnerNode,
michael@0:                  "Why do we still have our old sheet?");
michael@0: 
michael@0:     // Have to compare
michael@0:     if (nsContentUtils::PositionIsBefore(sheetOwnerNode, aLinkingContent)) {
michael@0:       // The current sheet comes before us, and it better be the first
michael@0:       // such, because now we break
michael@0:       break;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   ++insertionPoint; // adjust the index to the spot we want to insert in
michael@0: 
michael@0:   // XXX <meta> elements do not implement nsIStyleSheetLinkingElement;
michael@0:   // need to fix this for them to be ordered correctly.
michael@0:   nsCOMPtr<nsIStyleSheetLinkingElement>
michael@0:     linkingElement = do_QueryInterface(aLinkingContent);
michael@0:   if (linkingElement) {
michael@0:     linkingElement->SetStyleSheet(aSheet); // This sets the ownerNode on the sheet
michael@0:   }
michael@0: 
michael@0:   aDocument->BeginUpdate(UPDATE_STYLE);
michael@0:   aDocument->InsertStyleSheetAt(aSheet, insertionPoint);
michael@0:   aDocument->EndUpdate(UPDATE_STYLE);
michael@0:   LOG(("  Inserting into document at position %d", insertionPoint));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * InsertChildSheet handles ordering of @import-ed sheet in their
michael@0:  * parent sheets.  Here we want to just insert based on order of the
michael@0:  * @import rules that imported the sheets.  In theory we can't just
michael@0:  * append to the end because the CSSOM can insert @import rules.  In
michael@0:  * practice, we get the call to load the child sheet before the CSSOM
michael@0:  * has finished inserting the @import rule, so we have no idea where
michael@0:  * to put it anyway.  So just append for now.
michael@0:  */
michael@0: nsresult
michael@0: Loader::InsertChildSheet(nsCSSStyleSheet* aSheet,
michael@0:                          nsCSSStyleSheet* aParentSheet,
michael@0:                          ImportRule* aParentRule)
michael@0: {
michael@0:   LOG(("css::Loader::InsertChildSheet"));
michael@0:   NS_PRECONDITION(aSheet, "Nothing to insert");
michael@0:   NS_PRECONDITION(aParentSheet, "Need a parent to insert into");
michael@0:   NS_PRECONDITION(aParentSheet, "How did we get imported?");
michael@0: 
michael@0:   // child sheets should always start out enabled, even if they got
michael@0:   // cloned off of top-level sheets which were disabled
michael@0:   aSheet->SetEnabled(true);
michael@0: 
michael@0:   aParentSheet->AppendStyleSheet(aSheet);
michael@0:   aParentRule->SetSheet(aSheet); // This sets the ownerRule on the sheet
michael@0: 
michael@0:   LOG(("  Inserting into parent sheet"));
michael@0:   //  LOG(("  Inserting into parent sheet at position %d", insertionPoint));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * LoadSheet handles the actual load of a sheet.  If the load is
michael@0:  * supposed to be synchronous it just opens a channel synchronously
michael@0:  * using the given uri, wraps the resulting stream in a converter
michael@0:  * stream and calls ParseSheet.  Otherwise it tries to look for an
michael@0:  * existing load for this URI and piggyback on it.  Failing all that,
michael@0:  * a new load is kicked off asynchronously.
michael@0:  */
michael@0: nsresult
michael@0: Loader::LoadSheet(SheetLoadData* aLoadData, StyleSheetState aSheetState)
michael@0: {
michael@0:   LOG(("css::Loader::LoadSheet"));
michael@0:   NS_PRECONDITION(aLoadData, "Need a load data");
michael@0:   NS_PRECONDITION(aLoadData->mURI, "Need a URI to load");
michael@0:   NS_PRECONDITION(aLoadData->mSheet, "Need a sheet to load into");
michael@0:   NS_PRECONDITION(aSheetState != eSheetComplete, "Why bother?");
michael@0:   NS_PRECONDITION(!aLoadData->mUseSystemPrincipal || aLoadData->mSyncLoad,
michael@0:                   "Shouldn't use system principal for async loads");
michael@0:   NS_ASSERTION(mSheets, "mLoadingDatas should be initialized by now.");
michael@0: 
michael@0:   LOG_URI("  Load from: '%s'", aLoadData->mURI);
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0: 
michael@0:   if (!mDocument && !aLoadData->mIsNonDocumentSheet) {
michael@0:     // No point starting the load; just release all the data and such.
michael@0:     LOG_WARN(("  No document and not non-document sheet; pre-dropping load"));
michael@0:     SheetComplete(aLoadData, NS_BINDING_ABORTED);
michael@0:     return NS_BINDING_ABORTED;
michael@0:   }
michael@0: 
michael@0:   if (aLoadData->mSyncLoad) {
michael@0:     LOG(("  Synchronous load"));
michael@0:     NS_ASSERTION(!aLoadData->mObserver, "Observer for a sync load?");
michael@0:     NS_ASSERTION(aSheetState == eSheetNeedsParser,
michael@0:                  "Sync loads can't reuse existing async loads");
michael@0: 
michael@0:     // Create a nsIUnicharStreamLoader instance to which we will feed
michael@0:     // the data from the sync load.  Do this before creating the
michael@0:     // channel to make error recovery simpler.
michael@0:     nsCOMPtr<nsIUnicharStreamLoader> streamLoader;
michael@0:     rv = NS_NewUnicharStreamLoader(getter_AddRefs(streamLoader), aLoadData);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       LOG_ERROR(("  Failed to create stream loader for sync load"));
michael@0:       SheetComplete(aLoadData, rv);
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     if (mDocument) {
michael@0:       mozilla::net::SeerLearn(aLoadData->mURI, mDocument->GetDocumentURI(),
michael@0:                               nsINetworkSeer::LEARN_LOAD_SUBRESOURCE,
michael@0:                               mDocument);
michael@0:     }
michael@0: 
michael@0:     // Just load it
michael@0:     nsCOMPtr<nsIInputStream> stream;
michael@0:     nsCOMPtr<nsIChannel> channel;
michael@0:     rv = NS_OpenURI(getter_AddRefs(stream), aLoadData->mURI, nullptr,
michael@0:                     nullptr, nullptr, nsIRequest::LOAD_NORMAL,
michael@0:                     getter_AddRefs(channel));
michael@0:     if (NS_FAILED(rv)) {
michael@0:       LOG_ERROR(("  Failed to open URI synchronously"));
michael@0:       SheetComplete(aLoadData, rv);
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(channel, "NS_OpenURI lied?");
michael@0: 
michael@0:     // Force UA sheets to be UTF-8.
michael@0:     // XXX this is only necessary because the default in
michael@0:     // SheetLoadData::OnDetermineCharset is wrong (bug 521039).
michael@0:     channel->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
michael@0: 
michael@0:     // Manually feed the streamloader the contents of the stream we
michael@0:     // got from NS_OpenURI.  This will call back into OnStreamComplete
michael@0:     // and thence to ParseSheet.  Regardless of whether this fails,
michael@0:     // SheetComplete has been called.
michael@0:     return nsSyncLoadService::PushSyncStreamToListener(stream,
michael@0:                                                        streamLoader,
michael@0:                                                        channel);
michael@0:   }
michael@0: 
michael@0:   SheetLoadData* existingData = nullptr;
michael@0: 
michael@0:   URIPrincipalAndCORSModeHashKey key(aLoadData->mURI,
michael@0:                                      aLoadData->mLoaderPrincipal,
michael@0:                                      aLoadData->mSheet->GetCORSMode());
michael@0:   if (aSheetState == eSheetLoading) {
michael@0:     mSheets->mLoadingDatas.Get(&key, &existingData);
michael@0:     NS_ASSERTION(existingData, "CreateSheet lied about the state");
michael@0:   }
michael@0:   else if (aSheetState == eSheetPending){
michael@0:     mSheets->mPendingDatas.Get(&key, &existingData);
michael@0:     NS_ASSERTION(existingData, "CreateSheet lied about the state");
michael@0:   }
michael@0: 
michael@0:   if (existingData) {
michael@0:     LOG(("  Glomming on to existing load"));
michael@0:     SheetLoadData* data = existingData;
michael@0:     while (data->mNext) {
michael@0:       data = data->mNext;
michael@0:     }
michael@0:     data->mNext = aLoadData; // transfer ownership
michael@0:     if (aSheetState == eSheetPending && !aLoadData->mWasAlternate) {
michael@0:       // Kick the load off; someone cares about it right away
michael@0: 
michael@0: #ifdef DEBUG
michael@0:       SheetLoadData* removedData;
michael@0:       NS_ASSERTION(mSheets->mPendingDatas.Get(&key, &removedData) &&
michael@0:                    removedData == existingData,
michael@0:                    "Bad pending table.");
michael@0: #endif
michael@0: 
michael@0:       mSheets->mPendingDatas.Remove(&key);
michael@0: 
michael@0:       LOG(("  Forcing load of pending data"));
michael@0:       return LoadSheet(existingData, eSheetNeedsParser);
michael@0:     }
michael@0:     // All done here; once the load completes we'll be marked complete
michael@0:     // automatically
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   mSyncCallback = true;
michael@0: #endif
michael@0:   nsCOMPtr<nsILoadGroup> loadGroup;
michael@0:   // Content Security Policy information to pass into channel
michael@0:   nsCOMPtr<nsIChannelPolicy> channelPolicy;
michael@0:   if (mDocument) {
michael@0:     loadGroup = mDocument->GetDocumentLoadGroup();
michael@0:     NS_ASSERTION(loadGroup,
michael@0:                  "No loadgroup for stylesheet; onload will fire early");
michael@0:     nsCOMPtr<nsIContentSecurityPolicy> csp;
michael@0:     rv = mDocument->NodePrincipal()->GetCsp(getter_AddRefs(csp));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     if (csp) {
michael@0:       channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1");
michael@0:       channelPolicy->SetContentSecurityPolicy(csp);
michael@0:       channelPolicy->SetLoadType(nsIContentPolicy::TYPE_STYLESHEET);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIChannel> channel;
michael@0:   rv = NS_NewChannel(getter_AddRefs(channel),
michael@0:                      aLoadData->mURI, nullptr, loadGroup, nullptr,
michael@0:                      nsIChannel::LOAD_NORMAL | nsIChannel::LOAD_CLASSIFY_URI,
michael@0:                      channelPolicy);
michael@0: 
michael@0:   if (NS_FAILED(rv)) {
michael@0: #ifdef DEBUG
michael@0:     mSyncCallback = false;
michael@0: #endif
michael@0:     LOG_ERROR(("  Failed to create channel"));
michael@0:     SheetComplete(aLoadData, rv);
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIHttpChannelInternal>
michael@0:     internalHttpChannel(do_QueryInterface(channel));
michael@0:   if (internalHttpChannel)
michael@0:       internalHttpChannel->SetLoadAsBlocking(!aLoadData->mWasAlternate);
michael@0: 
michael@0:   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
michael@0:   if (httpChannel) {
michael@0:     // send a minimal Accept header for text/css
michael@0:     httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
michael@0:                                   NS_LITERAL_CSTRING("text/css,*/*;q=0.1"),
michael@0:                                   false);
michael@0:     nsCOMPtr<nsIURI> referrerURI = aLoadData->GetReferrerURI();
michael@0:     if (referrerURI)
michael@0:       httpChannel->SetReferrer(referrerURI);
michael@0: 
michael@0:     // Set the initiator type
michael@0:     nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(httpChannel));
michael@0:     if (timedChannel) {
michael@0:       if (aLoadData->mParentData) {
michael@0:         timedChannel->SetInitiatorType(NS_LITERAL_STRING("css"));
michael@0:       } else {
michael@0:         timedChannel->SetInitiatorType(NS_LITERAL_STRING("link"));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Now tell the channel we expect text/css data back....  We do
michael@0:   // this before opening it, so it's only treated as a hint.
michael@0:   channel->SetContentType(NS_LITERAL_CSTRING("text/css"));
michael@0: 
michael@0:   if (aLoadData->mLoaderPrincipal) {
michael@0:     bool inherit;
michael@0:     rv = NS_URIChainHasFlags(aLoadData->mURI,
michael@0:                              nsIProtocolHandler::URI_INHERITS_SECURITY_CONTEXT,
michael@0:                              &inherit);
michael@0:     if ((NS_SUCCEEDED(rv) && inherit) ||
michael@0:         (nsContentUtils::URIIsLocalFile(aLoadData->mURI) &&
michael@0:          NS_SUCCEEDED(aLoadData->mLoaderPrincipal->
michael@0:                       CheckMayLoad(aLoadData->mURI, false, false)))) {
michael@0:       channel->SetOwner(aLoadData->mLoaderPrincipal);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // We don't have to hold on to the stream loader.  The ownership
michael@0:   // model is: Necko owns the stream loader, which owns the load data,
michael@0:   // which owns us
michael@0:   nsCOMPtr<nsIUnicharStreamLoader> streamLoader;
michael@0:   rv = NS_NewUnicharStreamLoader(getter_AddRefs(streamLoader), aLoadData);
michael@0:   if (NS_FAILED(rv)) {
michael@0: #ifdef DEBUG
michael@0:     mSyncCallback = false;
michael@0: #endif
michael@0:     LOG_ERROR(("  Failed to create stream loader"));
michael@0:     SheetComplete(aLoadData, rv);
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIStreamListener> channelListener;
michael@0:   CORSMode ourCORSMode = aLoadData->mSheet->GetCORSMode();
michael@0:   if (ourCORSMode != CORS_NONE) {
michael@0:     bool withCredentials = (ourCORSMode == CORS_USE_CREDENTIALS);
michael@0:     LOG(("  Doing CORS-enabled load; credentials %d", withCredentials));
michael@0:     nsRefPtr<nsCORSListenerProxy> corsListener =
michael@0:       new nsCORSListenerProxy(streamLoader, aLoadData->mLoaderPrincipal,
michael@0: 			      withCredentials);
michael@0:     rv = corsListener->Init(channel);
michael@0:     if (NS_FAILED(rv)) {
michael@0: #ifdef DEBUG
michael@0:       mSyncCallback = false;
michael@0: #endif
michael@0:       LOG_ERROR(("  Initial CORS check failed"));
michael@0:       SheetComplete(aLoadData, rv);
michael@0:       return rv;
michael@0:     }
michael@0:     channelListener = corsListener;
michael@0:   } else {
michael@0:     channelListener = streamLoader;
michael@0:   }
michael@0: 
michael@0:   if (mDocument) {
michael@0:     mozilla::net::SeerLearn(aLoadData->mURI, mDocument->GetDocumentURI(),
michael@0:                             nsINetworkSeer::LEARN_LOAD_SUBRESOURCE, mDocument);
michael@0:   }
michael@0: 
michael@0:   rv = channel->AsyncOpen(channelListener, nullptr);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   mSyncCallback = false;
michael@0: #endif
michael@0: 
michael@0:   if (NS_FAILED(rv)) {
michael@0:     LOG_ERROR(("  Failed to create stream loader"));
michael@0:     SheetComplete(aLoadData, rv);
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   mSheets->mLoadingDatas.Put(&key, aLoadData);
michael@0:   aLoadData->mIsLoading = true;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * ParseSheet handles parsing the data stream.  The main idea here is
michael@0:  * to push the current load data onto the parse stack before letting
michael@0:  * the CSS parser at the data stream.  That lets us handle @import
michael@0:  * correctly.
michael@0:  */
michael@0: nsresult
michael@0: Loader::ParseSheet(const nsAString& aInput,
michael@0:                    SheetLoadData* aLoadData,
michael@0:                    bool& aCompleted)
michael@0: {
michael@0:   LOG(("css::Loader::ParseSheet"));
michael@0:   NS_PRECONDITION(aLoadData, "Must have load data");
michael@0:   NS_PRECONDITION(aLoadData->mSheet, "Must have sheet to parse into");
michael@0: 
michael@0:   aCompleted = false;
michael@0: 
michael@0:   nsCSSParser parser(this, aLoadData->mSheet);
michael@0: 
michael@0:   // Push our load data on the stack so any kids can pick it up
michael@0:   mParsingDatas.AppendElement(aLoadData);
michael@0:   nsIURI* sheetURI = aLoadData->mSheet->GetSheetURI();
michael@0:   nsIURI* baseURI = aLoadData->mSheet->GetBaseURI();
michael@0:   nsresult rv = parser.ParseSheet(aInput, sheetURI, baseURI,
michael@0:                                   aLoadData->mSheet->Principal(),
michael@0:                                   aLoadData->mLineNumber,
michael@0:                                   aLoadData->mAllowUnsafeRules);
michael@0:   mParsingDatas.RemoveElementAt(mParsingDatas.Length() - 1);
michael@0: 
michael@0:   if (NS_FAILED(rv)) {
michael@0:     LOG_ERROR(("  Low-level error in parser!"));
michael@0:     SheetComplete(aLoadData, rv);
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(aLoadData->mPendingChildren == 0 || !aLoadData->mSyncLoad,
michael@0:                "Sync load has leftover pending children!");
michael@0: 
michael@0:   if (aLoadData->mPendingChildren == 0) {
michael@0:     LOG(("  No pending kids from parse"));
michael@0:     aCompleted = true;
michael@0:     SheetComplete(aLoadData, NS_OK);
michael@0:   }
michael@0:   // Otherwise, the children are holding strong refs to the data and
michael@0:   // will call SheetComplete() on it when they complete.
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * SheetComplete is the do-it-all cleanup function.  It removes the
michael@0:  * load data from the "loading" hashtable, adds the sheet to the
michael@0:  * "completed" hashtable, massages the XUL cache, handles siblings of
michael@0:  * the load data (other loads for the same URI), handles unblocking
michael@0:  * blocked parent loads as needed, and most importantly calls
michael@0:  * NS_RELEASE on the load data to destroy the whole mess.
michael@0:  */
michael@0: void
michael@0: Loader::SheetComplete(SheetLoadData* aLoadData, nsresult aStatus)
michael@0: {
michael@0:   LOG(("css::Loader::SheetComplete"));
michael@0: 
michael@0:   // 8 is probably big enough for all our common cases.  It's not likely that
michael@0:   // imports will nest more than 8 deep, and multiple sheets with the same URI
michael@0:   // are rare.
michael@0:   nsAutoTArray<nsRefPtr<SheetLoadData>, 8> datasToNotify;
michael@0:   DoSheetComplete(aLoadData, aStatus, datasToNotify);
michael@0: 
michael@0:   // Now it's safe to go ahead and notify observers
michael@0:   uint32_t count = datasToNotify.Length();
michael@0:   mDatasToNotifyOn += count;
michael@0:   for (uint32_t i = 0; i < count; ++i) {
michael@0:     --mDatasToNotifyOn;
michael@0: 
michael@0:     SheetLoadData* data = datasToNotify[i];
michael@0:     NS_ASSERTION(data && data->mMustNotify, "How did this data get here?");
michael@0:     if (data->mObserver) {
michael@0:       LOG(("  Notifying observer 0x%x for data 0x%x.  wasAlternate: %d",
michael@0:            data->mObserver.get(), data, data->mWasAlternate));
michael@0:       data->mObserver->StyleSheetLoaded(data->mSheet, data->mWasAlternate,
michael@0:                                         aStatus);
michael@0:     }
michael@0: 
michael@0:     nsTObserverArray<nsCOMPtr<nsICSSLoaderObserver> >::ForwardIterator iter(mObservers);
michael@0:     nsCOMPtr<nsICSSLoaderObserver> obs;
michael@0:     while (iter.HasMore()) {
michael@0:       obs = iter.GetNext();
michael@0:       LOG(("  Notifying global observer 0x%x for data 0x%s.  wasAlternate: %d",
michael@0:            obs.get(), data, data->mWasAlternate));
michael@0:       obs->StyleSheetLoaded(data->mSheet, data->mWasAlternate, aStatus);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (mSheets->mLoadingDatas.Count() == 0 && mSheets->mPendingDatas.Count() > 0) {
michael@0:     LOG(("  No more loading sheets; starting alternates"));
michael@0:     StartAlternateLoads();
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::DoSheetComplete(SheetLoadData* aLoadData, nsresult aStatus,
michael@0:                         LoadDataArray& aDatasToNotify)
michael@0: {
michael@0:   LOG(("css::Loader::DoSheetComplete"));
michael@0:   NS_PRECONDITION(aLoadData, "Must have a load data!");
michael@0:   NS_PRECONDITION(aLoadData->mSheet, "Must have a sheet");
michael@0:   NS_ASSERTION(mSheets, "mLoadingDatas should be initialized by now.");
michael@0: 
michael@0:   LOG(("Load completed, status: 0x%x", aStatus));
michael@0: 
michael@0:   // Twiddle the hashtables
michael@0:   if (aLoadData->mURI) {
michael@0:     LOG_URI("  Finished loading: '%s'", aLoadData->mURI);
michael@0:     // Remove the data from the list of loading datas
michael@0:     if (aLoadData->mIsLoading) {
michael@0:       URIPrincipalAndCORSModeHashKey key(aLoadData->mURI,
michael@0:                                          aLoadData->mLoaderPrincipal,
michael@0:                                          aLoadData->mSheet->GetCORSMode());
michael@0: #ifdef DEBUG
michael@0:       SheetLoadData *loadingData;
michael@0:       NS_ASSERTION(mSheets->mLoadingDatas.Get(&key, &loadingData) &&
michael@0:                    loadingData == aLoadData,
michael@0:                    "Bad loading table");
michael@0: #endif
michael@0: 
michael@0:       mSheets->mLoadingDatas.Remove(&key);
michael@0:       aLoadData->mIsLoading = false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Go through and deal with the whole linked list.
michael@0:   SheetLoadData* data = aLoadData;
michael@0:   while (data) {
michael@0:     if (!data->mSheetAlreadyComplete) {
michael@0:       // If mSheetAlreadyComplete, then the sheet could well be modified between
michael@0:       // when we posted the async call to SheetComplete and now, since the sheet
michael@0:       // was page-accessible during that whole time.
michael@0:       NS_ABORT_IF_FALSE(!data->mSheet->IsModified(),
michael@0:                         "should not get marked modified during parsing");
michael@0:       data->mSheet->SetComplete();
michael@0:       data->ScheduleLoadEventIfNeeded(aStatus);
michael@0:     }
michael@0:     if (data->mMustNotify && (data->mObserver || !mObservers.IsEmpty())) {
michael@0:       // Don't notify here so we don't trigger script.  Remember the
michael@0:       // info we need to notify, then do it later when it's safe.
michael@0:       aDatasToNotify.AppendElement(data);
michael@0: 
michael@0:       // On append failure, just press on.  We'll fail to notify the observer,
michael@0:       // but not much we can do about that....
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(!data->mParentData ||
michael@0:                  data->mParentData->mPendingChildren != 0,
michael@0:                  "Broken pending child count on our parent");
michael@0: 
michael@0:     // If we have a parent, our parent is no longer being parsed, and
michael@0:     // we are the last pending child, then our load completion
michael@0:     // completes the parent too.  Note that the parent _can_ still be
michael@0:     // being parsed (eg if the child (us) failed to open the channel
michael@0:     // or some such).
michael@0:     if (data->mParentData &&
michael@0:         --(data->mParentData->mPendingChildren) == 0 &&
michael@0:         !mParsingDatas.Contains(data->mParentData)) {
michael@0:       DoSheetComplete(data->mParentData, aStatus, aDatasToNotify);
michael@0:     }
michael@0: 
michael@0:     data = data->mNext;
michael@0:   }
michael@0: 
michael@0:   // Now that it's marked complete, put the sheet in our cache.
michael@0:   // If we ever start doing this for failure aStatus, we'll need to
michael@0:   // adjust the PostLoadEvent code that thinks anything already
michael@0:   // complete must have loaded succesfully.
michael@0:   if (NS_SUCCEEDED(aStatus) && aLoadData->mURI) {
michael@0:     // Pick our sheet to cache carefully.  Ideally, we want to cache
michael@0:     // one of the sheets that will be kept alive by a document or
michael@0:     // parent sheet anyway, so that if someone then accesses it via
michael@0:     // CSSOM we won't have extra clones of the inner lying around.
michael@0:     data = aLoadData;
michael@0:     nsCSSStyleSheet* sheet = aLoadData->mSheet;
michael@0:     while (data) {
michael@0:       if (data->mSheet->GetParentSheet() || data->mSheet->GetOwnerNode()) {
michael@0:         sheet = data->mSheet;
michael@0:         break;
michael@0:       }
michael@0:       data = data->mNext;
michael@0:     }
michael@0: #ifdef MOZ_XUL
michael@0:     if (IsChromeURI(aLoadData->mURI)) {
michael@0:       nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
michael@0:       if (cache && cache->IsEnabled()) {
michael@0:         if (!cache->GetStyleSheet(aLoadData->mURI)) {
michael@0:           LOG(("  Putting sheet in XUL prototype cache"));
michael@0:           NS_ASSERTION(sheet->IsComplete(),
michael@0:                        "Should only be caching complete sheets");
michael@0:           cache->PutStyleSheet(sheet);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0: #endif
michael@0:       URIPrincipalAndCORSModeHashKey key(aLoadData->mURI,
michael@0:                                          aLoadData->mLoaderPrincipal,
michael@0:                                          aLoadData->mSheet->GetCORSMode());
michael@0:       NS_ASSERTION(sheet->IsComplete(),
michael@0:                    "Should only be caching complete sheets");
michael@0:       mSheets->mCompleteSheets.Put(&key, sheet);
michael@0: #ifdef MOZ_XUL
michael@0:     }
michael@0: #endif
michael@0:   }
michael@0: 
michael@0:   NS_RELEASE(aLoadData);  // this will release parents and siblings and all that
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadInlineStyle(nsIContent* aElement,
michael@0:                         const nsAString& aBuffer,
michael@0:                         uint32_t aLineNumber,
michael@0:                         const nsAString& aTitle,
michael@0:                         const nsAString& aMedia,
michael@0:                         Element* aScopeElement,
michael@0:                         nsICSSLoaderObserver* aObserver,
michael@0:                         bool* aCompleted,
michael@0:                         bool* aIsAlternate)
michael@0: {
michael@0:   LOG(("css::Loader::LoadInlineStyle"));
michael@0:   NS_ASSERTION(mParsingDatas.Length() == 0, "We're in the middle of a parse?");
michael@0: 
michael@0:   *aCompleted = true;
michael@0: 
michael@0:   if (!mEnabled) {
michael@0:     LOG_WARN(("  Not enabled"));
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_INITIALIZED);
michael@0: 
michael@0:   nsCOMPtr<nsIStyleSheetLinkingElement> owningElement(do_QueryInterface(aElement));
michael@0:   NS_ASSERTION(owningElement, "Element is not a style linking element!");
michael@0: 
michael@0:   // Since we're not planning to load a URI, no need to hand a principal to the
michael@0:   // load data or to CreateSheet().  Also, OK to use CORS_NONE for the CORS
michael@0:   // mode.
michael@0:   StyleSheetState state;
michael@0:   nsRefPtr<nsCSSStyleSheet> sheet;
michael@0:   nsresult rv = CreateSheet(nullptr, aElement, nullptr, CORS_NONE, false, false,
michael@0:                             aTitle, state, aIsAlternate, getter_AddRefs(sheet));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:   NS_ASSERTION(state == eSheetNeedsParser,
michael@0:                "Inline sheets should not be cached");
michael@0: 
michael@0:   LOG(("  Sheet is alternate: %d", *aIsAlternate));
michael@0: 
michael@0:   PrepareSheet(sheet, aTitle, aMedia, nullptr, aScopeElement, *aIsAlternate);
michael@0: 
michael@0:   if (aElement->HasFlag(NODE_IS_IN_SHADOW_TREE)) {
michael@0:     ShadowRoot* containingShadow = aElement->GetContainingShadow();
michael@0:     MOZ_ASSERT(containingShadow);
michael@0:     containingShadow->InsertSheet(sheet, aElement);
michael@0:   } else {
michael@0:     rv = InsertSheetInDoc(sheet, aElement, mDocument);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:   }
michael@0: 
michael@0:   SheetLoadData* data = new SheetLoadData(this, aTitle, nullptr, sheet,
michael@0:                                           owningElement, *aIsAlternate,
michael@0:                                           aObserver, nullptr);
michael@0: 
michael@0:   // We never actually load this, so just set its principal directly
michael@0:   sheet->SetPrincipal(aElement->NodePrincipal());
michael@0: 
michael@0:   NS_ADDREF(data);
michael@0:   data->mLineNumber = aLineNumber;
michael@0:   // Parse completion releases the load data
michael@0:   rv = ParseSheet(aBuffer, data, *aCompleted);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   // If aCompleted is true, |data| may well be deleted by now.
michael@0:   if (!*aCompleted) {
michael@0:     data->mMustNotify = true;
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadStyleLink(nsIContent* aElement,
michael@0:                       nsIURI* aURL,
michael@0:                       const nsAString& aTitle,
michael@0:                       const nsAString& aMedia,
michael@0:                       bool aHasAlternateRel,
michael@0:                       CORSMode aCORSMode,
michael@0:                       nsICSSLoaderObserver* aObserver,
michael@0:                       bool* aIsAlternate)
michael@0: {
michael@0:   LOG(("css::Loader::LoadStyleLink"));
michael@0:   NS_PRECONDITION(aURL, "Must have URL to load");
michael@0:   NS_ASSERTION(mParsingDatas.Length() == 0, "We're in the middle of a parse?");
michael@0: 
michael@0:   LOG_URI("  Link uri: '%s'", aURL);
michael@0:   LOG(("  Link title: '%s'", NS_ConvertUTF16toUTF8(aTitle).get()));
michael@0:   LOG(("  Link media: '%s'", NS_ConvertUTF16toUTF8(aMedia).get()));
michael@0:   LOG(("  Link alternate rel: %d", aHasAlternateRel));
michael@0: 
michael@0:   if (!mEnabled) {
michael@0:     LOG_WARN(("  Not enabled"));
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_INITIALIZED);
michael@0: 
michael@0:   nsIPrincipal* principal =
michael@0:     aElement ? aElement->NodePrincipal() : mDocument->NodePrincipal();
michael@0: 
michael@0:   nsISupports* context = aElement;
michael@0:   if (!context) {
michael@0:     context = mDocument;
michael@0:   }
michael@0:   nsresult rv = CheckLoadAllowed(principal, aURL, context);
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   LOG(("  Passed load check"));
michael@0: 
michael@0:   StyleSheetState state;
michael@0:   nsRefPtr<nsCSSStyleSheet> sheet;
michael@0:   rv = CreateSheet(aURL, aElement, principal, aCORSMode, false,
michael@0:                    aHasAlternateRel, aTitle, state, aIsAlternate,
michael@0:                    getter_AddRefs(sheet));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   LOG(("  Sheet is alternate: %d", *aIsAlternate));
michael@0: 
michael@0:   PrepareSheet(sheet, aTitle, aMedia, nullptr, nullptr, *aIsAlternate);
michael@0: 
michael@0:   rv = InsertSheetInDoc(sheet, aElement, mDocument);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsCOMPtr<nsIStyleSheetLinkingElement> owningElement(do_QueryInterface(aElement));
michael@0: 
michael@0:   if (state == eSheetComplete) {
michael@0:     LOG(("  Sheet already complete: 0x%p",
michael@0:          static_cast<void*>(sheet.get())));
michael@0:     if (aObserver || !mObservers.IsEmpty() || owningElement) {
michael@0:       rv = PostLoadEvent(aURL, sheet, aObserver, *aIsAlternate,
michael@0:                          owningElement);
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Now we need to actually load it
michael@0:   SheetLoadData* data = new SheetLoadData(this, aTitle, aURL, sheet,
michael@0:                                           owningElement, *aIsAlternate,
michael@0:                                           aObserver, principal);
michael@0:   NS_ADDREF(data);
michael@0: 
michael@0:   // If we have to parse and it's an alternate non-inline, defer it
michael@0:   if (aURL && state == eSheetNeedsParser && mSheets->mLoadingDatas.Count() != 0 &&
michael@0:       *aIsAlternate) {
michael@0:     LOG(("  Deferring alternate sheet load"));
michael@0:     URIPrincipalAndCORSModeHashKey key(data->mURI, data->mLoaderPrincipal,
michael@0:                                        data->mSheet->GetCORSMode());
michael@0:     mSheets->mPendingDatas.Put(&key, data);
michael@0: 
michael@0:     data->mMustNotify = true;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Load completion will free the data
michael@0:   rv = LoadSheet(data, state);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   data->mMustNotify = true;
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: HaveAncestorDataWithURI(SheetLoadData *aData, nsIURI *aURI)
michael@0: {
michael@0:   if (!aData->mURI) {
michael@0:     // Inline style; this won't have any ancestors
michael@0:     NS_ABORT_IF_FALSE(!aData->mParentData,
michael@0:                       "How does inline style have a parent?");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   bool equal;
michael@0:   if (NS_FAILED(aData->mURI->Equals(aURI, &equal)) || equal) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Datas down the mNext chain have the same URI as aData, so we
michael@0:   // don't have to compare to them.  But they might have different
michael@0:   // parents, and we have to check all of those.
michael@0:   while (aData) {
michael@0:     if (aData->mParentData &&
michael@0:         HaveAncestorDataWithURI(aData->mParentData, aURI)) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     aData = aData->mNext;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadChildSheet(nsCSSStyleSheet* aParentSheet,
michael@0:                        nsIURI* aURL,
michael@0:                        nsMediaList* aMedia,
michael@0:                        ImportRule* aParentRule)
michael@0: {
michael@0:   LOG(("css::Loader::LoadChildSheet"));
michael@0:   NS_PRECONDITION(aURL, "Must have a URI to load");
michael@0:   NS_PRECONDITION(aParentSheet, "Must have a parent sheet");
michael@0: 
michael@0:   if (!mEnabled) {
michael@0:     LOG_WARN(("  Not enabled"));
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0:   }
michael@0: 
michael@0:   LOG_URI("  Child uri: '%s'", aURL);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMNode> owningNode;
michael@0: 
michael@0:   // check for an owning document: if none, don't bother walking up the parent
michael@0:   // sheets
michael@0:   if (aParentSheet->GetOwningDocument()) {
michael@0:     nsCOMPtr<nsIDOMStyleSheet> nextParentSheet(aParentSheet);
michael@0:     NS_ENSURE_TRUE(nextParentSheet, NS_ERROR_FAILURE); //Not a stylesheet!?
michael@0: 
michael@0:     nsCOMPtr<nsIDOMStyleSheet> topSheet;
michael@0:     //traverse our way to the top-most sheet
michael@0:     do {
michael@0:       topSheet.swap(nextParentSheet);
michael@0:       topSheet->GetParentStyleSheet(getter_AddRefs(nextParentSheet));
michael@0:     } while (nextParentSheet);
michael@0: 
michael@0:     topSheet->GetOwnerNode(getter_AddRefs(owningNode));
michael@0:   }
michael@0: 
michael@0:   nsISupports* context = owningNode;
michael@0:   if (!context) {
michael@0:     context = mDocument;
michael@0:   }
michael@0: 
michael@0:   nsIPrincipal* principal = aParentSheet->Principal();
michael@0:   nsresult rv = CheckLoadAllowed(principal, aURL, context);
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   LOG(("  Passed load check"));
michael@0: 
michael@0:   SheetLoadData* parentData = nullptr;
michael@0:   nsCOMPtr<nsICSSLoaderObserver> observer;
michael@0: 
michael@0:   int32_t count = mParsingDatas.Length();
michael@0:   if (count > 0) {
michael@0:     LOG(("  Have a parent load"));
michael@0:     parentData = mParsingDatas.ElementAt(count - 1);
michael@0:     // Check for cycles
michael@0:     if (HaveAncestorDataWithURI(parentData, aURL)) {
michael@0:       // Houston, we have a loop, blow off this child and pretend this never
michael@0:       // happened
michael@0:       LOG_ERROR(("  @import cycle detected, dropping load"));
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(parentData->mSheet == aParentSheet,
michael@0:                  "Unexpected call to LoadChildSheet");
michael@0:   } else {
michael@0:     LOG(("  No parent load; must be CSSOM"));
michael@0:     // No parent load data, so the sheet will need to be notified when
michael@0:     // we finish, if it can be, if we do the load asynchronously.
michael@0:     observer = aParentSheet;
michael@0:   }
michael@0: 
michael@0:   // Now that we know it's safe to load this (passes security check and not a
michael@0:   // loop) do so.
michael@0:   nsRefPtr<nsCSSStyleSheet> sheet;
michael@0:   bool isAlternate;
michael@0:   StyleSheetState state;
michael@0:   const nsSubstring& empty = EmptyString();
michael@0:   // For now, use CORS_NONE for child sheets
michael@0:   rv = CreateSheet(aURL, nullptr, principal, CORS_NONE,
michael@0:                    parentData ? parentData->mSyncLoad : false,
michael@0:                    false, empty, state, &isAlternate, getter_AddRefs(sheet));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   PrepareSheet(sheet, empty, empty, aMedia, nullptr, isAlternate);
michael@0: 
michael@0:   rv = InsertChildSheet(sheet, aParentSheet, aParentRule);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (state == eSheetComplete) {
michael@0:     LOG(("  Sheet already complete"));
michael@0:     // We're completely done.  No need to notify, even, since the
michael@0:     // @import rule addition/modification will trigger the right style
michael@0:     // changes automatically.
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   SheetLoadData* data = new SheetLoadData(this, aURL, sheet, parentData,
michael@0:                                           observer, principal);
michael@0: 
michael@0:   NS_ADDREF(data);
michael@0:   bool syncLoad = data->mSyncLoad;
michael@0: 
michael@0:   // Load completion will release the data
michael@0:   rv = LoadSheet(data, state);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   // If syncLoad is true, |data| will be deleted by now.
michael@0:   if (!syncLoad) {
michael@0:     data->mMustNotify = true;
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadSheetSync(nsIURI* aURL, bool aAllowUnsafeRules,
michael@0:                       bool aUseSystemPrincipal,
michael@0:                       nsCSSStyleSheet** aSheet)
michael@0: {
michael@0:   LOG(("css::Loader::LoadSheetSync"));
michael@0:   return InternalLoadNonDocumentSheet(aURL, aAllowUnsafeRules,
michael@0:                                       aUseSystemPrincipal, nullptr,
michael@0:                                       EmptyCString(), aSheet, nullptr);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadSheet(nsIURI* aURL,
michael@0:                   nsIPrincipal* aOriginPrincipal,
michael@0:                   const nsCString& aCharset,
michael@0:                   nsICSSLoaderObserver* aObserver,
michael@0:                   nsCSSStyleSheet** aSheet)
michael@0: {
michael@0:   LOG(("css::Loader::LoadSheet(aURL, aObserver, aSheet) api call"));
michael@0:   NS_PRECONDITION(aSheet, "aSheet is null");
michael@0:   return InternalLoadNonDocumentSheet(aURL, false, false,
michael@0:                                       aOriginPrincipal, aCharset,
michael@0:                                       aSheet, aObserver);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::LoadSheet(nsIURI* aURL,
michael@0:                   nsIPrincipal* aOriginPrincipal,
michael@0:                   const nsCString& aCharset,
michael@0:                   nsICSSLoaderObserver* aObserver,
michael@0:                   CORSMode aCORSMode)
michael@0: {
michael@0:   LOG(("css::Loader::LoadSheet(aURL, aObserver) api call"));
michael@0:   return InternalLoadNonDocumentSheet(aURL, false, false,
michael@0:                                       aOriginPrincipal, aCharset,
michael@0:                                       nullptr, aObserver, aCORSMode);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::InternalLoadNonDocumentSheet(nsIURI* aURL,
michael@0:                                      bool aAllowUnsafeRules,
michael@0:                                      bool aUseSystemPrincipal,
michael@0:                                      nsIPrincipal* aOriginPrincipal,
michael@0:                                      const nsCString& aCharset,
michael@0:                                      nsCSSStyleSheet** aSheet,
michael@0:                                      nsICSSLoaderObserver* aObserver,
michael@0:                                      CORSMode aCORSMode)
michael@0: {
michael@0:   NS_PRECONDITION(aURL, "Must have a URI to load");
michael@0:   NS_PRECONDITION(aSheet || aObserver, "Sheet and observer can't both be null");
michael@0:   NS_PRECONDITION(!aUseSystemPrincipal || !aObserver,
michael@0:                   "Shouldn't load system-principal sheets async");
michael@0:   NS_ASSERTION(mParsingDatas.Length() == 0, "We're in the middle of a parse?");
michael@0: 
michael@0:   LOG_URI("  Non-document sheet uri: '%s'", aURL);
michael@0: 
michael@0:   if (aSheet) {
michael@0:     *aSheet = nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!mEnabled) {
michael@0:     LOG_WARN(("  Not enabled"));
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = CheckLoadAllowed(aOriginPrincipal, aURL, mDocument);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   StyleSheetState state;
michael@0:   bool isAlternate;
michael@0:   nsRefPtr<nsCSSStyleSheet> sheet;
michael@0:   bool syncLoad = (aObserver == nullptr);
michael@0:   const nsSubstring& empty = EmptyString();
michael@0: 
michael@0:   rv = CreateSheet(aURL, nullptr, aOriginPrincipal, aCORSMode, syncLoad, false,
michael@0:                    empty, state, &isAlternate, getter_AddRefs(sheet));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   PrepareSheet(sheet, empty, empty, nullptr, nullptr, isAlternate);
michael@0: 
michael@0:   if (state == eSheetComplete) {
michael@0:     LOG(("  Sheet already complete"));
michael@0:     if (aObserver || !mObservers.IsEmpty()) {
michael@0:       rv = PostLoadEvent(aURL, sheet, aObserver, false, nullptr);
michael@0:     }
michael@0:     if (aSheet) {
michael@0:       sheet.swap(*aSheet);
michael@0:     }
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   SheetLoadData* data =
michael@0:     new SheetLoadData(this, aURL, sheet, syncLoad, aAllowUnsafeRules,
michael@0:                       aUseSystemPrincipal, aCharset, aObserver,
michael@0:                       aOriginPrincipal);
michael@0: 
michael@0:   NS_ADDREF(data);
michael@0:   rv = LoadSheet(data, state);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (aSheet) {
michael@0:     sheet.swap(*aSheet);
michael@0:   }
michael@0:   if (aObserver) {
michael@0:     data->mMustNotify = true;
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::PostLoadEvent(nsIURI* aURI,
michael@0:                       nsCSSStyleSheet* aSheet,
michael@0:                       nsICSSLoaderObserver* aObserver,
michael@0:                       bool aWasAlternate,
michael@0:                       nsIStyleSheetLinkingElement* aElement)
michael@0: {
michael@0:   LOG(("css::Loader::PostLoadEvent"));
michael@0:   NS_PRECONDITION(aSheet, "Must have sheet");
michael@0:   NS_PRECONDITION(aObserver || !mObservers.IsEmpty() || aElement,
michael@0:                   "Must have observer or element");
michael@0: 
michael@0:   nsRefPtr<SheetLoadData> evt =
michael@0:     new SheetLoadData(this, EmptyString(), // title doesn't matter here
michael@0:                       aURI,
michael@0:                       aSheet,
michael@0:                       aElement,
michael@0:                       aWasAlternate,
michael@0:                       aObserver,
michael@0:                       nullptr);
michael@0:   NS_ENSURE_TRUE(evt, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:   if (!mPostedEvents.AppendElement(evt)) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = NS_DispatchToCurrentThread(evt);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     NS_WARNING("failed to dispatch stylesheet load event");
michael@0:     mPostedEvents.RemoveElement(evt);
michael@0:   } else {
michael@0:     // We'll unblock onload when we handle the event.
michael@0:     if (mDocument) {
michael@0:       mDocument->BlockOnload();
michael@0:     }
michael@0: 
michael@0:     // We want to notify the observer for this data.
michael@0:     evt->mMustNotify = true;
michael@0:     evt->mSheetAlreadyComplete = true;
michael@0: 
michael@0:     // If we get to this code, aSheet loaded correctly at some point, so
michael@0:     // we can just use NS_OK for the status.  Note that we do this here
michael@0:     // and not from inside our SheetComplete so that we don't end up
michael@0:     // running the load event async.
michael@0:     evt->ScheduleLoadEventIfNeeded(NS_OK);
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::HandleLoadEvent(SheetLoadData* aEvent)
michael@0: {
michael@0:   // XXXbz can't assert this yet.... May not have an observer because
michael@0:   // we're unblocking the parser
michael@0:   // NS_ASSERTION(aEvent->mObserver, "Must have observer");
michael@0:   NS_ASSERTION(aEvent->mSheet, "Must have sheet");
michael@0: 
michael@0:   // Very important: this needs to come before the SheetComplete call
michael@0:   // below, so that HasPendingLoads() will test true as needed under
michael@0:   // notifications we send from that SheetComplete call.
michael@0:   mPostedEvents.RemoveElement(aEvent);
michael@0: 
michael@0:   if (!aEvent->mIsCancelled) {
michael@0:     // SheetComplete will call Release(), so give it a reference to do
michael@0:     // that with.
michael@0:     NS_ADDREF(aEvent);
michael@0:     SheetComplete(aEvent, NS_OK);
michael@0:   }
michael@0: 
michael@0:   if (mDocument) {
michael@0:     mDocument->UnblockOnload(true);
michael@0:   }
michael@0: }
michael@0: 
michael@0: static PLDHashOperator
michael@0: StopLoadingSheetCallback(URIPrincipalAndCORSModeHashKey* aKey,
michael@0:                          SheetLoadData*& aData,
michael@0:                          void* aClosure)
michael@0: {
michael@0:   NS_PRECONDITION(aData, "Must have a data!");
michael@0:   NS_PRECONDITION(aClosure, "Must have a loader");
michael@0: 
michael@0:   aData->mIsLoading = false; // we will handle the removal right here
michael@0:   aData->mIsCancelled = true;
michael@0: 
michael@0:   static_cast<Loader::LoadDataArray*>(aClosure)->AppendElement(aData);
michael@0: 
michael@0:   return PL_DHASH_REMOVE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::Stop()
michael@0: {
michael@0:   uint32_t pendingCount =
michael@0:     mSheets ? mSheets->mPendingDatas.Count() : 0;
michael@0:   uint32_t loadingCount =
michael@0:     mSheets ? mSheets->mLoadingDatas.Count() : 0;
michael@0:   LoadDataArray arr(pendingCount + loadingCount + mPostedEvents.Length());
michael@0: 
michael@0:   if (pendingCount) {
michael@0:     mSheets->mPendingDatas.Enumerate(StopLoadingSheetCallback, &arr);
michael@0:   }
michael@0:   if (loadingCount) {
michael@0:     mSheets->mLoadingDatas.Enumerate(StopLoadingSheetCallback, &arr);
michael@0:   }
michael@0: 
michael@0:   uint32_t i;
michael@0:   for (i = 0; i < mPostedEvents.Length(); ++i) {
michael@0:     SheetLoadData* data = mPostedEvents[i];
michael@0:     data->mIsCancelled = true;
michael@0:     if (arr.AppendElement(data)) {
michael@0:       // SheetComplete() calls Release(), so give this an extra ref.
michael@0:       NS_ADDREF(data);
michael@0:     }
michael@0: #ifdef DEBUG
michael@0:     else {
michael@0:       NS_NOTREACHED("We preallocated this memory... shouldn't really fail, "
michael@0:                     "except we never check that preallocation succeeds.");
michael@0:     }
michael@0: #endif
michael@0:   }
michael@0:   mPostedEvents.Clear();
michael@0: 
michael@0:   mDatasToNotifyOn += arr.Length();
michael@0:   for (i = 0; i < arr.Length(); ++i) {
michael@0:     --mDatasToNotifyOn;
michael@0:     SheetComplete(arr[i], NS_BINDING_ABORTED);
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Loader::HasPendingLoads()
michael@0: {
michael@0:   return
michael@0:     (mSheets && mSheets->mLoadingDatas.Count() != 0) ||
michael@0:     (mSheets && mSheets->mPendingDatas.Count() != 0) ||
michael@0:     mPostedEvents.Length() != 0 ||
michael@0:     mDatasToNotifyOn != 0;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Loader::AddObserver(nsICSSLoaderObserver* aObserver)
michael@0: {
michael@0:   NS_PRECONDITION(aObserver, "Must have observer");
michael@0:   if (mObservers.AppendElementUnlessExists(aObserver)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_OUT_OF_MEMORY;
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::RemoveObserver(nsICSSLoaderObserver* aObserver)
michael@0: {
michael@0:   mObservers.RemoveElement(aObserver);
michael@0: }
michael@0: 
michael@0: static PLDHashOperator
michael@0: CollectLoadDatas(URIPrincipalAndCORSModeHashKey *aKey,
michael@0:                  SheetLoadData* &aData,
michael@0:                  void* aClosure)
michael@0: {
michael@0:   static_cast<Loader::LoadDataArray*>(aClosure)->AppendElement(aData);
michael@0:   return PL_DHASH_REMOVE;
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::StartAlternateLoads()
michael@0: {
michael@0:   NS_PRECONDITION(mSheets, "Don't call me!");
michael@0:   LoadDataArray arr(mSheets->mPendingDatas.Count());
michael@0:   mSheets->mPendingDatas.Enumerate(CollectLoadDatas, &arr);
michael@0: 
michael@0:   mDatasToNotifyOn += arr.Length();
michael@0:   for (uint32_t i = 0; i < arr.Length(); ++i) {
michael@0:     --mDatasToNotifyOn;
michael@0:     LoadSheet(arr[i], eSheetNeedsParser);
michael@0:   }
michael@0: }
michael@0: 
michael@0: static PLDHashOperator
michael@0: TraverseSheet(URIPrincipalAndCORSModeHashKey*,
michael@0:               nsCSSStyleSheet* aSheet,
michael@0:               void* aClosure)
michael@0: {
michael@0:   nsCycleCollectionTraversalCallback* cb =
michael@0:     static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
michael@0:   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "Sheet cache nsCSSLoader");
michael@0:   cb->NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIStyleSheet*, aSheet));
michael@0:   return PL_DHASH_NEXT;
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::TraverseCachedSheets(nsCycleCollectionTraversalCallback& cb)
michael@0: {
michael@0:   if (mSheets) {
michael@0:     mSheets->mCompleteSheets.EnumerateRead(TraverseSheet, &cb);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: Loader::UnlinkCachedSheets()
michael@0: {
michael@0:   if (mSheets) {
michael@0:     mSheets->mCompleteSheets.Clear();
michael@0:   }
michael@0: }
michael@0: 
michael@0: struct SheetMemoryCounter {
michael@0:   size_t size;
michael@0:   mozilla::MallocSizeOf mallocSizeOf;
michael@0: };
michael@0: 
michael@0: static size_t
michael@0: CountSheetMemory(URIPrincipalAndCORSModeHashKey* /* unused */,
michael@0:                  const nsRefPtr<nsCSSStyleSheet>& aSheet,
michael@0:                  mozilla::MallocSizeOf aMallocSizeOf,
michael@0:                  void* /* unused */)
michael@0: {
michael@0:   // If aSheet has a parent, then its parent will report it so we don't
michael@0:   // have to worry about it here.
michael@0:   // Likewise, if aSheet has an owning node, then the document that
michael@0:   // node is in will report it.
michael@0:   if (aSheet->GetOwnerNode() || aSheet->GetParentSheet()) {
michael@0:     return 0;
michael@0:   }
michael@0:   return aSheet->SizeOfIncludingThis(aMallocSizeOf);
michael@0: }
michael@0: 
michael@0: size_t
michael@0: Loader::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
michael@0: {
michael@0:   size_t s = aMallocSizeOf(this);
michael@0: 
michael@0:   if (mSheets) {
michael@0:     s += mSheets->mCompleteSheets.SizeOfExcludingThis(CountSheetMemory, aMallocSizeOf);
michael@0:   }
michael@0:   s += mObservers.SizeOfExcludingThis(aMallocSizeOf);
michael@0: 
michael@0:   // Measurement of the following members may be added later if DMD finds it is
michael@0:   // worthwhile:
michael@0:   // - mLoadingDatas: transient, and should be small
michael@0:   // - mPendingDatas: transient, and should be small
michael@0:   // - mParsingDatas: transient, and should be small
michael@0:   // - mPostedEvents: transient, and should be small
michael@0:   //
michael@0:   // The following members aren't measured:
michael@0:   // - mDocument, because it's a weak backpointer
michael@0:   // - mPreferredSheet, because it can be a shared string
michael@0: 
michael@0:   return s;
michael@0: }
michael@0: 
michael@0: } // namespace css
michael@0: } // namespace mozilla