// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "core/dom/CompositorProxy.h"

#include "bindings/core/v8/ExceptionMessages.h"
#include "bindings/core/v8/ExceptionState.h"
#include "core/dom/DOMNodeIds.h"
#include "core/dom/ExceptionCode.h"
#include "core/dom/ExecutionContext.h"
#include "core/workers/WorkerClients.h"
#include "core/workers/WorkerGlobalScope.h"
#include "platform/CrossThreadFunctional.h"
#include "platform/graphics/CompositorMutableProperties.h"
#include "public/platform/Platform.h"
#include "public/platform/WebTraceLocation.h"
#include <algorithm>

namespace blink {

static const struct {
  const char* name;
  uint32_t property;
} allowedProperties[] = {
    {"opacity", CompositorMutableProperty::kOpacity},
    {"scrollleft", CompositorMutableProperty::kScrollLeft},
    {"scrolltop", CompositorMutableProperty::kScrollTop},
    {"transform", CompositorMutableProperty::kTransform},
};

static uint32_t compositorMutablePropertyForName(const String& attributeName) {
  for (const auto& mapping : allowedProperties) {
    if (equalIgnoringCase(mapping.name, attributeName))
      return mapping.property;
  }
  return CompositorMutableProperty::kNone;
}

static bool isControlThread() {
  return !isMainThread();
}

static bool isCallingCompositorFrameCallback() {
  // TODO(sad): Check that the requestCompositorFrame callbacks are currently
  // being called.
  return true;
}

static void decrementCompositorProxiedPropertiesForElement(
    uint64_t elementId,
    uint32_t compositorMutableProperties) {
  DCHECK(isMainThread());
  Node* node = DOMNodeIds::nodeForId(elementId);
  if (!node)
    return;
  Element* element = toElement(node);
  element->decrementCompositorProxiedProperties(compositorMutableProperties);
}

static void incrementCompositorProxiedPropertiesForElement(
    uint64_t elementId,
    uint32_t compositorMutableProperties) {
  DCHECK(isMainThread());
  Node* node = DOMNodeIds::nodeForId(elementId);
  if (!node)
    return;
  Element* element = toElement(node);
  element->incrementCompositorProxiedProperties(compositorMutableProperties);
}

static bool raiseExceptionIfMutationNotAllowed(ExceptionState& exceptionState) {
  if (!isControlThread()) {
    exceptionState.throwDOMException(
        NoModificationAllowedError,
        "Cannot mutate a proxy attribute from the main page.");
    return true;
  }
  if (!isCallingCompositorFrameCallback()) {
    exceptionState.throwDOMException(NoModificationAllowedError,
                                     "Cannot mutate a proxy attribute outside "
                                     "of a requestCompositorFrame callback.");
    return true;
  }
  return false;
}

static uint32_t compositorMutablePropertiesFromNames(
    const Vector<String>& attributeArray) {
  uint32_t properties = 0;
  for (const auto& attribute : attributeArray) {
    properties |= compositorMutablePropertyForName(attribute);
  }
  return properties;
}

#if DCHECK_IS_ON()
static bool sanityCheckMutableProperties(uint32_t properties) {
  // Ensures that we only have bits set for valid mutable properties.
  uint32_t sanityCheckProperties = properties;
  for (unsigned i = 0; i < WTF_ARRAY_LENGTH(allowedProperties); ++i) {
    sanityCheckProperties &=
        ~static_cast<uint32_t>(allowedProperties[i].property);
  }
  return !sanityCheckProperties;
}
#endif

CompositorProxy* CompositorProxy::create(ExecutionContext* context,
                                         Element* element,
                                         const Vector<String>& attributeArray,
                                         ExceptionState& exceptionState) {
  if (!context->isDocument()) {
    exceptionState.throwTypeError(ExceptionMessages::failedToConstruct(
        "CompositorProxy", "Can only be created from the main context."));
    return nullptr;
  }

  return new CompositorProxy(*element, attributeArray);
}

CompositorProxy* CompositorProxy::create(ExecutionContext* context,
                                         uint64_t elementId,
                                         uint32_t compositorMutableProperties) {
  if (context->isCompositorWorkerGlobalScope()) {
    WorkerClients* clients = toWorkerGlobalScope(context)->clients();
    DCHECK(clients);
    CompositorProxyClient* client = CompositorProxyClient::from(clients);
    return new CompositorProxy(elementId, compositorMutableProperties, client);
  }

  return new CompositorProxy(elementId, compositorMutableProperties);
}

CompositorProxy::CompositorProxy(uint64_t elementId,
                                 uint32_t compositorMutableProperties)
    : m_elementId(elementId),
      m_compositorMutableProperties(compositorMutableProperties),
      m_client(nullptr) {
  DCHECK(m_compositorMutableProperties);
#if DCHECK_IS_ON()
  DCHECK(sanityCheckMutableProperties(m_compositorMutableProperties));
#endif

  if (isMainThread()) {
    incrementCompositorProxiedPropertiesForElement(
        m_elementId, m_compositorMutableProperties);
  } else {
    Platform::current()->mainThread()->getWebTaskRunner()->postTask(
        BLINK_FROM_HERE,
        crossThreadBind(&incrementCompositorProxiedPropertiesForElement,
                        m_elementId, m_compositorMutableProperties));
  }
}

CompositorProxy::CompositorProxy(Element& element,
                                 const Vector<String>& attributeArray)
    : CompositorProxy(DOMNodeIds::idForNode(&element),
                      compositorMutablePropertiesFromNames(attributeArray)) {
  DCHECK(isMainThread());
}

CompositorProxy::CompositorProxy(uint64_t elementId,
                                 uint32_t compositorMutableProperties,
                                 CompositorProxyClient* client)
    : CompositorProxy(elementId, compositorMutableProperties) {
  m_client = client;
  DCHECK(m_client);
  DCHECK(isControlThread());
  m_client->registerCompositorProxy(this);
}

CompositorProxy::~CompositorProxy() {
  // We do not explicitly unregister from client here. The client has a weak
  // reference to us which gets collected on its own. This way we avoid using
  // a pre-finalizer.
  disconnectInternal();
  DCHECK(!m_connected);
}

bool CompositorProxy::supports(const String& attributeName) const {
  return m_compositorMutableProperties &
         compositorMutablePropertyForName(attributeName);
}

double CompositorProxy::opacity(ExceptionState& exceptionState) const {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return 0.0;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kOpacity,
                                 exceptionState))
    return 0.0;
  return m_state->opacity();
}

double CompositorProxy::scrollLeft(ExceptionState& exceptionState) const {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return 0.0;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollLeft,
                                 exceptionState))
    return 0.0;
  return m_state->scrollLeft();
}

double CompositorProxy::scrollTop(ExceptionState& exceptionState) const {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return 0.0;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollTop,
                                 exceptionState))
    return 0.0;
  return m_state->scrollTop();
}

DOMMatrix* CompositorProxy::transform(ExceptionState& exceptionState) const {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return nullptr;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kTransform,
                                 exceptionState))
    return nullptr;
  return DOMMatrix::create(m_state->transform(), exceptionState);
}

void CompositorProxy::setOpacity(double opacity,
                                 ExceptionState& exceptionState) {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kOpacity,
                                 exceptionState))
    return;
  m_state->setOpacity(std::min(1., std::max(0., opacity)));
}

void CompositorProxy::setScrollLeft(double scrollLeft,
                                    ExceptionState& exceptionState) {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollLeft,
                                 exceptionState))
    return;
  m_state->setScrollLeft(scrollLeft);
}

void CompositorProxy::setScrollTop(double scrollTop,
                                   ExceptionState& exceptionState) {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollTop,
                                 exceptionState))
    return;
  m_state->setScrollTop(scrollTop);
}

void CompositorProxy::setTransform(DOMMatrix* transform,
                                   ExceptionState& exceptionState) {
  if (raiseExceptionIfMutationNotAllowed(exceptionState))
    return;
  if (raiseExceptionIfNotMutable(CompositorMutableProperty::kTransform,
                                 exceptionState))
    return;
  m_state->setTransform(
      TransformationMatrix::toSkMatrix44(transform->matrix()));
}

void CompositorProxy::takeCompositorMutableState(
    std::unique_ptr<CompositorMutableState> state) {
  m_state = std::move(state);
}

bool CompositorProxy::raiseExceptionIfNotMutable(
    uint32_t property,
    ExceptionState& exceptionState) const {
  if (!m_connected)
    exceptionState.throwDOMException(
        NoModificationAllowedError,
        "Attempted to mutate attribute on a disconnected proxy.");
  else if (!(m_compositorMutableProperties & property))
    exceptionState.throwDOMException(
        NoModificationAllowedError,
        "Attempted to mutate non-mutable attribute.");
  else if (!m_state)
    exceptionState.throwDOMException(
        NoModificationAllowedError,
        "Attempted to mutate attribute on an uninitialized proxy.");

  return exceptionState.hadException();
}

void CompositorProxy::disconnect() {
  disconnectInternal();
  if (m_client)
    m_client->unregisterCompositorProxy(this);
}

void CompositorProxy::disconnectInternal() {
  if (!m_connected)
    return;
  m_connected = false;
  if (isMainThread()) {
    decrementCompositorProxiedPropertiesForElement(
        m_elementId, m_compositorMutableProperties);
  } else {
    Platform::current()->mainThread()->getWebTaskRunner()->postTask(
        BLINK_FROM_HERE,
        crossThreadBind(&decrementCompositorProxiedPropertiesForElement,
                        m_elementId, m_compositorMutableProperties));
  }
}

}  // namespace blink