gecko-dev/dom/script/ScriptLoadRequest.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_ScriptLoadRequest_h
#define mozilla_dom_ScriptLoadRequest_h

#include "mozilla/CORSMode.h"
#include "mozilla/dom/SRIMetadata.h"
#include "mozilla/LinkedList.h"
#include "mozilla/Maybe.h"
#include "mozilla/net/ReferrerPolicy.h"
#include "mozilla/Variant.h"
#include "mozilla/Vector.h"
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIScriptElement.h"

class nsICacheInfoChannel;

namespace mozilla {
namespace dom {

class ModuleLoadRequest;
class ScriptLoadRequestList;

enum class ScriptKind {
  eClassic,
  eModule
};

/*
 * Some options used when fetching script resources. This only loosely
 * corresponds to HTML's "script fetch options".
 *
 * These are common to all modules in a module graph, and hence a single
 * instance is shared by all ModuleLoadRequest objects in a graph.
 */

class ScriptFetchOptions
{
  ~ScriptFetchOptions();

public:
  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(ScriptFetchOptions)
  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(ScriptFetchOptions)

  ScriptFetchOptions(mozilla::CORSMode aCORSMode,
                     mozilla::net::ReferrerPolicy aReferrerPolicy,
                     nsIScriptElement* aElement,
                     nsIPrincipal* aTriggeringPrincipal);

  const mozilla::CORSMode mCORSMode;
  const mozilla::net::ReferrerPolicy mReferrerPolicy;
  nsCOMPtr<nsIScriptElement> mElement;
  nsCOMPtr<nsIPrincipal> mTriggeringPrincipal;
};

/*
 * A class that handles loading and evaluation of <script> elements.
 */

class ScriptLoadRequest : public nsISupports,
                          private mozilla::LinkedListElement<ScriptLoadRequest>
{
  typedef LinkedListElement<ScriptLoadRequest> super;

  // Allow LinkedListElement<ScriptLoadRequest> to cast us to itself as needed.
  friend class mozilla::LinkedListElement<ScriptLoadRequest>;
  friend class ScriptLoadRequestList;

protected:
  virtual ~ScriptLoadRequest();

public:
  ScriptLoadRequest(ScriptKind aKind,
                    nsIURI* aURI,
                    ScriptFetchOptions* aFetchOptions,
                    const SRIMetadata &aIntegrity,
                    nsIURI* aReferrer);

  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ScriptLoadRequest)

  bool IsModuleRequest() const
  {
    return mKind == ScriptKind::eModule;
  }

  ModuleLoadRequest* AsModuleRequest();

  void FireScriptAvailable(nsresult aResult)
  {
    bool isInlineClassicScript = mIsInline && !IsModuleRequest();
    Element()->ScriptAvailable(aResult, Element(), isInlineClassicScript, mURI,
                              mLineNo);
  }
  void FireScriptEvaluated(nsresult aResult)
  {
    Element()->ScriptEvaluated(aResult, Element(), mIsInline);
  }

  bool IsPreload()
  {
    return Element() == nullptr;
  }

  virtual void Cancel();

  bool IsCanceled() const
  {
    return mIsCanceled;
  }

  virtual void SetReady();

  JS::OffThreadToken** OffThreadTokenPtr()
  {
    return mOffThreadToken ?  &mOffThreadToken : nullptr;
  }

  bool IsTracking() const
  {
    return mIsTracking;
  }
  void SetIsTracking()
  {
    MOZ_ASSERT(!mIsTracking);
    mIsTracking = true;
  }

  enum class Progress : uint8_t {
    eLoading,        // Request either source or bytecode
    eLoading_Source, // Explicitly Request source stream
    eCompiling,
    eFetchingImports,
    eReady
  };

  bool IsReadyToRun() const
  {
    return mProgress == Progress::eReady;
  }
  bool IsLoading() const
  {
    return mProgress == Progress::eLoading ||
           mProgress == Progress::eLoading_Source;
  }
  bool IsLoadingSource() const
  {
    return mProgress == Progress::eLoading_Source;
  }
  bool InCompilingStage() const
  {
    return mProgress == Progress::eCompiling ||
           (IsReadyToRun() && mWasCompiledOMT);
  }

  // Type of data provided by the nsChannel.
  enum class DataType : uint8_t {
    eUnknown,
    eTextSource,
    eBinASTSource,
    eBytecode
  };

  bool IsUnknownDataType() const
  {
    return mDataType == DataType::eUnknown;
  }
  bool IsTextSource() const
  {
    return mDataType == DataType::eTextSource;
  }
  bool IsBinASTSource() const
  {
#ifdef JS_BUILD_BINAST
    return mDataType == DataType::eBinASTSource;
#else
    return false;
#endif
  }
  bool IsSource() const
  {
    return IsTextSource() || IsBinASTSource();
  }
  bool IsBytecode() const
  {
    return mDataType == DataType::eBytecode;
  }

  void SetUnknownDataType();
  void SetTextSource();
  void SetBinASTSource();
  void SetBytecode();

  using ScriptTextBuffer = Vector<char16_t, 0, JSMallocAllocPolicy>;
  using BinASTSourceBuffer = Vector<uint8_t>;

  const ScriptTextBuffer& ScriptText() const
  {
    MOZ_ASSERT(IsTextSource());
    return mScriptData->as<ScriptTextBuffer>();
  }
  ScriptTextBuffer& ScriptText()
  {
    MOZ_ASSERT(IsTextSource());
    return mScriptData->as<ScriptTextBuffer>();
  }
  const BinASTSourceBuffer& ScriptBinASTData() const
  {
    MOZ_ASSERT(IsBinASTSource());
    return mScriptData->as<BinASTSourceBuffer>();
  }
  BinASTSourceBuffer& ScriptBinASTData()
  {
    MOZ_ASSERT(IsBinASTSource());
    return mScriptData->as<BinASTSourceBuffer>();
  }

  enum class ScriptMode : uint8_t {
    eBlocking,
    eDeferred,
    eAsync
  };

  void SetScriptMode(bool aDeferAttr, bool aAsyncAttr);

  bool IsBlockingScript() const
  {
    return mScriptMode == ScriptMode::eBlocking;
  }

  bool IsDeferredScript() const
  {
    return mScriptMode == ScriptMode::eDeferred;
  }

  bool IsAsyncScript() const
  {
    return mScriptMode == ScriptMode::eAsync;
  }

  virtual bool IsTopLevel() const
  {
    // Classic scripts are always top level.
    return true;
  }

  mozilla::CORSMode CORSMode() const
  {
    return mFetchOptions->mCORSMode;
  }
  mozilla::net::ReferrerPolicy ReferrerPolicy() const
  {
    return mFetchOptions->mReferrerPolicy;
  }
  nsIScriptElement* Element() const
  {
    return mFetchOptions->mElement;
  }
  nsIPrincipal* TriggeringPrincipal() const
  {
    return mFetchOptions->mTriggeringPrincipal;
  }

  void SetElement(nsIScriptElement* aElement)
  {
    // Called when a preload request is later used for an actual request.
    MOZ_ASSERT(aElement);
    MOZ_ASSERT(!Element());
    mFetchOptions->mElement = aElement;
  }

  bool ShouldAcceptBinASTEncoding() const;

  void ClearScriptSource();

  void MaybeCancelOffThreadScript();
  void DropBytecodeCacheReferences();

  using super::getNext;
  using super::isInList;

  const ScriptKind mKind; // Whether this is a classic script or a module script.
  ScriptMode mScriptMode; // Whether this is a blocking, defer or async script.
  Progress mProgress;     // Are we still waiting for a load to complete?
  DataType mDataType;     // Does this contain Source or Bytecode?
  bool mScriptFromHead;   // Synchronous head script block loading of other non js/css content.
  bool mIsInline;         // Is the script inline or loaded?
  bool mHasSourceMapURL;  // Does the HTTP header have a source map url?
  bool mInDeferList;      // True if we live in mDeferRequests.
  bool mInAsyncList;      // True if we live in mLoadingAsyncRequests or mLoadedAsyncRequests.
  bool mIsNonAsyncScriptInserted; // True if we live in mNonAsyncExternalScriptInsertedRequests
  bool mIsXSLT;           // True if we live in mXSLTRequests.
  bool mIsCanceled;       // True if we have been explicitly canceled.
  bool mWasCompiledOMT;   // True if the script has been compiled off main thread.
  bool mIsTracking;       // True if the script comes from a source on our tracking protection list.

  RefPtr<ScriptFetchOptions> mFetchOptions;

  JS::OffThreadToken* mOffThreadToken; // Off-thread parsing token.
  nsString mSourceMapURL; // Holds source map url for loaded scripts

  // Holds the top-level JSScript that corresponds to the current source, once
  // it is parsed, and planned to be saved in the bytecode cache.
  JS::Heap<JSScript*> mScript;

  // Holds script source data for non-inline scripts. Don't use nsString so we
  // can give ownership to jsapi. Holds either char16_t source text characters
  // or BinAST encoded bytes depending on mSourceEncoding.
  Maybe<Variant<ScriptTextBuffer, BinASTSourceBuffer>> mScriptData;

  // The length of script source text, set when reading completes. This is used
  // since mScriptData is cleared when the source is passed to the JS engine.
  size_t mScriptTextLength;

  // Holds the SRI serialized hash and the script bytecode for non-inline
  // scripts.
  mozilla::Vector<uint8_t> mScriptBytecode;
  uint32_t mBytecodeOffset; // Offset of the bytecode in mScriptBytecode

  const nsCOMPtr<nsIURI> mURI;
  nsCOMPtr<nsIPrincipal> mOriginPrincipal;
  nsAutoCString mURL;     // Keep the URI's filename alive during off thread parsing.
  int32_t mLineNo;
  const SRIMetadata mIntegrity;
  const nsCOMPtr<nsIURI> mReferrer;

  // Holds the Cache information, which is used to register the bytecode
  // on the cache entry, such that we can load it the next time.
  nsCOMPtr<nsICacheInfoChannel> mCacheInfo;
};

class ScriptLoadRequestList : private mozilla::LinkedList<ScriptLoadRequest>
{
  typedef mozilla::LinkedList<ScriptLoadRequest> super;

public:
  ~ScriptLoadRequestList();

  void Clear();

#ifdef DEBUG
  bool Contains(ScriptLoadRequest* aElem) const;
#endif // DEBUG

  using super::getFirst;
  using super::isEmpty;

  void AppendElement(ScriptLoadRequest* aElem)
  {
    MOZ_ASSERT(!aElem->isInList());
    NS_ADDREF(aElem);
    insertBack(aElem);
  }

  MOZ_MUST_USE
  already_AddRefed<ScriptLoadRequest> Steal(ScriptLoadRequest* aElem)
  {
    aElem->removeFrom(*this);
    return dont_AddRef(aElem);
  }

  MOZ_MUST_USE
  already_AddRefed<ScriptLoadRequest> StealFirst()
  {
    MOZ_ASSERT(!isEmpty());
    return Steal(getFirst());
  }

  void Remove(ScriptLoadRequest* aElem)
  {
    aElem->removeFrom(*this);
    NS_RELEASE(aElem);
  }
};

void
ImplCycleCollectionUnlink(ScriptLoadRequestList& aField);

void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
                            ScriptLoadRequestList& aField,
                            const char* aName,
                            uint32_t aFlags);

} // namespace dom
} // namespace mozilla

#endif // mozilla_dom_ScriptLoadRequest_h