/*
 * Copyright (C) 2009 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef DOMDataStore_h
#define DOMDataStore_h

#include "bindings/core/v8/DOMWrapperMap.h"
#include "bindings/core/v8/DOMWrapperWorld.h"
#include "bindings/core/v8/ScriptWrappable.h"
#include "bindings/core/v8/WrapperTypeInfo.h"
#include "wtf/Allocator.h"
#include "wtf/Noncopyable.h"
#include "wtf/PtrUtil.h"
#include "wtf/StdLibExtras.h"
#include <memory>
#include <v8.h>

namespace blink {

class Node;

class DOMDataStore {
  WTF_MAKE_NONCOPYABLE(DOMDataStore);
  USING_FAST_MALLOC(DOMDataStore);

 public:
  DOMDataStore(v8::Isolate* isolate, bool isMainWorld)
      : m_isMainWorld(isMainWorld)
        // We never use |m_wrapperMap| when it's the main world.
        ,
        m_wrapperMap(wrapUnique(
            isMainWorld ? nullptr
                        : new DOMWrapperMap<ScriptWrappable>(isolate))) {}

  static DOMDataStore& current(v8::Isolate* isolate) {
    return DOMWrapperWorld::current(isolate).domDataStore();
  }

  static bool setReturnValue(v8::ReturnValue<v8::Value> returnValue,
                             ScriptWrappable* object) {
    return current(returnValue.GetIsolate())
        .setReturnValueFrom(returnValue, object);
  }

  static bool setReturnValue(v8::ReturnValue<v8::Value> returnValue,
                             Node* object) {
    if (canUseScriptWrappable(object))
      return ScriptWrappable::fromNode(object)->setReturnValue(returnValue);
    return current(returnValue.GetIsolate())
        .setReturnValueFrom(returnValue, ScriptWrappable::fromNode(object));
  }

  static bool setReturnValueForMainWorld(v8::ReturnValue<v8::Value> returnValue,
                                         ScriptWrappable* object) {
    return object->setReturnValue(returnValue);
  }

  static bool setReturnValueFast(v8::ReturnValue<v8::Value> returnValue,
                                 ScriptWrappable* object,
                                 v8::Local<v8::Object> holder,
                                 const ScriptWrappable* wrappable) {
    // The second fastest way to check if we're in the main world is to check if
    // the wrappable's wrapper is the same as the holder.
    if (holderContainsWrapper(holder, wrappable))
      return object->setReturnValue(returnValue);
    return current(returnValue.GetIsolate())
        .setReturnValueFrom(returnValue, object);
  }

  static bool setReturnValueFast(v8::ReturnValue<v8::Value> returnValue,
                                 Node* node,
                                 v8::Local<v8::Object> holder,
                                 const ScriptWrappable* wrappable) {
    if (canUseScriptWrappable(node)
        // The second fastest way to check if we're in the main world is to
        // check if the wrappable's wrapper is the same as the holder.
        || holderContainsWrapper(holder, wrappable))
      return ScriptWrappable::fromNode(node)->setReturnValue(returnValue);
    return current(returnValue.GetIsolate())
        .setReturnValueFrom(returnValue, ScriptWrappable::fromNode(node));
  }

  static v8::Local<v8::Object> getWrapper(ScriptWrappable* object,
                                          v8::Isolate* isolate) {
    return current(isolate).get(object, isolate);
  }

  static v8::Local<v8::Object> getWrapper(Node* node, v8::Isolate* isolate) {
    if (canUseScriptWrappable(node))
      return ScriptWrappable::fromNode(node)->mainWorldWrapper(isolate);
    return current(isolate).get(ScriptWrappable::fromNode(node), isolate);
  }

  static void setWrapperReference(const v8::Persistent<v8::Object>& parent,
                                  ScriptWrappable* child,
                                  v8::Isolate* isolate) {
    current(isolate).setReference(parent, child, isolate);
  }

  static void setWrapperReference(const v8::Persistent<v8::Object>& parent,
                                  Node* child,
                                  v8::Isolate* isolate) {
    if (canUseScriptWrappable(child)) {
      ScriptWrappable::fromNode(child)->setReference(parent, isolate);
      return;
    }
    current(isolate).setReference(parent, ScriptWrappable::fromNode(child),
                                  isolate);
  }

  // Associates the given |object| with the given |wrapper| if the object is
  // not yet associated with any wrapper.  Returns true if the given wrapper
  // is associated with the object, or false if the object is already
  // associated with a wrapper.  In the latter case, |wrapper| will be updated
  // to the existing wrapper.
  static bool setWrapper(v8::Isolate* isolate,
                         ScriptWrappable* object,
                         const WrapperTypeInfo* wrapperTypeInfo,
                         v8::Local<v8::Object>& wrapper) WARN_UNUSED_RETURN {
    return current(isolate).set(isolate, object, wrapperTypeInfo, wrapper);
  }

  static bool setWrapper(v8::Isolate* isolate,
                         Node* node,
                         const WrapperTypeInfo* wrapperTypeInfo,
                         v8::Local<v8::Object>& wrapper) WARN_UNUSED_RETURN {
    if (canUseScriptWrappable(node))
      return ScriptWrappable::fromNode(node)->setWrapper(
          isolate, wrapperTypeInfo, wrapper);
    return current(isolate).set(isolate, ScriptWrappable::fromNode(node),
                                wrapperTypeInfo, wrapper);
  }

  static bool containsWrapper(ScriptWrappable* object, v8::Isolate* isolate) {
    return current(isolate).containsWrapper(object);
  }

  v8::Local<v8::Object> get(ScriptWrappable* object, v8::Isolate* isolate) {
    if (m_isMainWorld)
      return object->mainWorldWrapper(isolate);
    return m_wrapperMap->newLocal(isolate, object);
  }

  void markWrapper(v8::EmbedderReachableReferenceReporter* reporter,
                   ScriptWrappable* scriptWrappable) {
    m_wrapperMap->markWrapper(reporter, scriptWrappable);
  }

  void setReference(const v8::Persistent<v8::Object>& parent,
                    ScriptWrappable* child,
                    v8::Isolate* isolate) {
    if (m_isMainWorld) {
      child->setReference(parent, isolate);
      return;
    }
    m_wrapperMap->setReference(isolate, parent, child);
  }

  bool setReturnValueFrom(v8::ReturnValue<v8::Value> returnValue,
                          ScriptWrappable* object) {
    if (m_isMainWorld)
      return object->setReturnValue(returnValue);
    return m_wrapperMap->setReturnValueFrom(returnValue, object);
  }

  bool containsWrapper(ScriptWrappable* object) {
    if (m_isMainWorld)
      return object->containsWrapper();
    return m_wrapperMap->containsKey(object);
  }

 private:
  bool set(v8::Isolate* isolate,
           ScriptWrappable* object,
           const WrapperTypeInfo* wrapperTypeInfo,
           v8::Local<v8::Object>& wrapper) WARN_UNUSED_RETURN {
    ASSERT(object);
    ASSERT(!wrapper.IsEmpty());
    if (m_isMainWorld)
      return object->setWrapper(isolate, wrapperTypeInfo, wrapper);
    return m_wrapperMap->set(object, wrapperTypeInfo, wrapper);
  }

  // We can use a wrapper stored in a ScriptWrappable when we're in the main world.
  // This method does the fast check if we're in the main world. If this method returns true,
  // it is guaranteed that we're in the main world. On the other hand, if this method returns
  // false, nothing is guaranteed (we might be in the main world).
  static bool canUseScriptWrappable(Node*) {
    // This helper function itself doesn't use the argument, but we have to
    // make sure that the argument is type of Node* because Node and its
    // subclasses satisfy the following two conditions.
    //   1. Nodes never exist in worker.
    //   2. Node inherits from ScriptWrappable.
    // and if there exists no isolated world, we're sure that we're in the
    // main world and we can use ScriptWrappable's wrapper.
    return !DOMWrapperWorld::isolatedWorldsExist();
  }

  static bool holderContainsWrapper(v8::Local<v8::Object> holder,
                                    const ScriptWrappable* wrappable) {
    // Verify our assumptions about the main world.
    ASSERT(wrappable);
    ASSERT(!wrappable->containsWrapper() || !wrappable->isEqualTo(holder) ||
           current(v8::Isolate::GetCurrent()).m_isMainWorld);
    return wrappable->isEqualTo(holder);
  }

  bool m_isMainWorld;
  std::unique_ptr<DOMWrapperMap<ScriptWrappable>> m_wrapperMap;
};

template <>
inline void DOMWrapperMap<ScriptWrappable>::PersistentValueMapTraits::Dispose(
    v8::Isolate*,
    v8::Global<v8::Object> value,
    ScriptWrappable*) {
  toWrapperTypeInfo(value)->wrapperDestroyed();
}

template <>
inline void
DOMWrapperMap<ScriptWrappable>::PersistentValueMapTraits::DisposeWeak(
    const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {
  auto wrapperTypeInfo = reinterpret_cast<WrapperTypeInfo*>(
      data.GetInternalField(v8DOMWrapperTypeIndex));
  wrapperTypeInfo->wrapperDestroyed();
}

}  // namespace blink

#endif  // DOMDataStore_h