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

#include "ModuleLoadRequest.h"

#include "mozilla/HoldDropJSObjects.h"
#include "mozilla/Unused.h"

#include "nsICacheInfoChannel.h"
#include "ScriptLoadRequest.h"
#include "ScriptSettings.h"

namespace mozilla {
namespace dom {

//////////////////////////////////////////////////////////////
// ScriptFetchOptions
//////////////////////////////////////////////////////////////

NS_IMPL_CYCLE_COLLECTION(ScriptFetchOptions,
                         mElement,
                         mTriggeringPrincipal)

NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(ScriptFetchOptions, AddRef)
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(ScriptFetchOptions, Release)

ScriptFetchOptions::ScriptFetchOptions(mozilla::CORSMode aCORSMode,
                                       mozilla::net::ReferrerPolicy aReferrerPolicy,
                                       nsIScriptElement* aElement,
                                       nsIPrincipal* aTriggeringPrincipal)
  : mCORSMode(aCORSMode)
  , mReferrerPolicy(aReferrerPolicy)
  , mElement(aElement)
  , mTriggeringPrincipal(aTriggeringPrincipal)
{
  MOZ_ASSERT(mTriggeringPrincipal);
}

ScriptFetchOptions::~ScriptFetchOptions()
{}

//////////////////////////////////////////////////////////////
// ScriptLoadRequest
//////////////////////////////////////////////////////////////

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ScriptLoadRequest)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(ScriptLoadRequest)
NS_IMPL_CYCLE_COLLECTING_RELEASE(ScriptLoadRequest)

NS_IMPL_CYCLE_COLLECTION_CLASS(ScriptLoadRequest)

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ScriptLoadRequest)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mFetchOptions)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCacheInfo)
  tmp->DropBytecodeCacheReferences();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(ScriptLoadRequest)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFetchOptions)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCacheInfo)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(ScriptLoadRequest)
  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mScript)
NS_IMPL_CYCLE_COLLECTION_TRACE_END

ScriptLoadRequest::ScriptLoadRequest(ScriptKind aKind,
                                     nsIURI* aURI,
                                     ScriptFetchOptions* aFetchOptions,
                                     const SRIMetadata &aIntegrity,
                                     nsIURI* aReferrer)
  : mKind(aKind)
  , mScriptMode(ScriptMode::eBlocking)
  , mProgress(Progress::eLoading)
  , mDataType(DataType::eUnknown)
  , mScriptFromHead(false)
  , mIsInline(true)
  , mHasSourceMapURL(false)
  , mInDeferList(false)
  , mInAsyncList(false)
  , mIsNonAsyncScriptInserted(false)
  , mIsXSLT(false)
  , mIsCanceled(false)
  , mWasCompiledOMT(false)
  , mIsTracking(false)
  , mFetchOptions(aFetchOptions)
  , mOffThreadToken(nullptr)
  , mScriptTextLength(0)
  , mScriptBytecode()
  , mBytecodeOffset(0)
  , mURI(aURI)
  , mLineNo(1)
  , mIntegrity(aIntegrity)
  , mReferrer(aReferrer)
{
  MOZ_ASSERT(mFetchOptions);
}

ScriptLoadRequest::~ScriptLoadRequest()
{
  // We should always clean up any off-thread script parsing resources.
  MOZ_ASSERT(!mOffThreadToken);

  // But play it safe in release builds and try to clean them up here
  // as a fail safe.
  MaybeCancelOffThreadScript();

  if (mScript) {
    DropBytecodeCacheReferences();
  }
}

void
ScriptLoadRequest::SetReady()
{
  MOZ_ASSERT(mProgress != Progress::eReady);
  mProgress = Progress::eReady;
}

void
ScriptLoadRequest::Cancel()
{
  MaybeCancelOffThreadScript();
  mIsCanceled = true;
}

void
ScriptLoadRequest::MaybeCancelOffThreadScript()
{
  MOZ_ASSERT(NS_IsMainThread());

  if (!mOffThreadToken) {
    return;
  }

  JSContext* cx = danger::GetJSContext();
  // Follow the same conditions as ScriptLoader::AttemptAsyncScriptCompile
  if (IsModuleRequest()) {
    JS::CancelOffThreadModule(cx, mOffThreadToken);
  } else if (IsSource()) {
    JS::CancelOffThreadScript(cx, mOffThreadToken);
  } else {
    MOZ_ASSERT(IsBytecode());
    JS::CancelOffThreadScriptDecoder(cx, mOffThreadToken);
  }
  mOffThreadToken = nullptr;
}

void
ScriptLoadRequest::DropBytecodeCacheReferences()
{
  mCacheInfo = nullptr;
  mScript = nullptr;
  DropJSObjects(this);
}

inline ModuleLoadRequest*
ScriptLoadRequest::AsModuleRequest()
{
  MOZ_ASSERT(IsModuleRequest());
  return static_cast<ModuleLoadRequest*>(this);
}

void
ScriptLoadRequest::SetScriptMode(bool aDeferAttr, bool aAsyncAttr)
{
  if (aAsyncAttr) {
    mScriptMode = ScriptMode::eAsync;
  } else if (aDeferAttr || IsModuleRequest()) {
    mScriptMode = ScriptMode::eDeferred;
  } else {
    mScriptMode = ScriptMode::eBlocking;
  }
}

void
ScriptLoadRequest::SetUnknownDataType()
{
  mDataType = DataType::eUnknown;
  mScriptData.reset();
}

void
ScriptLoadRequest::SetTextSource()
{
  MOZ_ASSERT(IsUnknownDataType());
  mDataType = DataType::eTextSource;
  mScriptData.emplace(VariantType<ScriptTextBuffer>());
}

void
ScriptLoadRequest::SetBinASTSource()
{
#ifdef JS_BUILD_BINAST
  MOZ_ASSERT(IsUnknownDataType());
  mDataType = DataType::eBinASTSource;
  mScriptData.emplace(VariantType<BinASTSourceBuffer>());
#else
  MOZ_CRASH("BinAST not supported");
#endif
}

void
ScriptLoadRequest::SetBytecode()
{
  MOZ_ASSERT(IsUnknownDataType());
  mDataType = DataType::eBytecode;
}

bool
ScriptLoadRequest::ShouldAcceptBinASTEncoding() const
{
#ifdef JS_BUILD_BINAST
  // We accept the BinAST encoding if we're using a secure connection.

  bool isHTTPS = false;
  nsresult rv = mURI->SchemeIs("https", &isHTTPS);
  MOZ_ASSERT(NS_SUCCEEDED(rv));
  Unused << rv;

  return isHTTPS;
#else
  MOZ_CRASH("BinAST not supported");
#endif
}

void
ScriptLoadRequest::ClearScriptSource()
{
  if (IsTextSource()) {
    ScriptText().clearAndFree();
  } else if (IsBinASTSource()) {
    ScriptBinASTData().clearAndFree();
  }
}

//////////////////////////////////////////////////////////////
// ScriptLoadRequestList
//////////////////////////////////////////////////////////////

ScriptLoadRequestList::~ScriptLoadRequestList()
{
  Clear();
}

void
ScriptLoadRequestList::Clear()
{
  while (!isEmpty()) {
    RefPtr<ScriptLoadRequest> first = StealFirst();
    first->Cancel();
    // And just let it go out of scope and die.
  }
}

#ifdef DEBUG
bool
ScriptLoadRequestList::Contains(ScriptLoadRequest* aElem) const
{
  for (const ScriptLoadRequest* req = getFirst();
       req; req = req->getNext()) {
    if (req == aElem) {
      return true;
    }
  }

  return false;
}
#endif // DEBUG

inline void
ImplCycleCollectionUnlink(ScriptLoadRequestList& aField)
{
  while (!aField.isEmpty()) {
    RefPtr<ScriptLoadRequest> first = aField.StealFirst();
  }
}

inline void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
                            ScriptLoadRequestList& aField,
                            const char* aName,
                            uint32_t aFlags)
{
  for (ScriptLoadRequest* request = aField.getFirst();
       request; request = request->getNext())
  {
    CycleCollectionNoteChild(aCallback, request, aName, aFlags);
  }
}

} // dom namespace
} // mozilla namespace