/* -*- 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 "mozilla/dom/HTMLSharedElement.h"

#include "mozilla/dom/HTMLBaseElementBinding.h"

#include "mozilla/dom/HTMLDirectoryElementBinding.h"

#include "mozilla/dom/HTMLHeadElementBinding.h"

#include "mozilla/dom/HTMLHtmlElementBinding.h"

#include "mozilla/dom/HTMLParamElementBinding.h"

#include "mozilla/dom/HTMLQuoteElementBinding.h"

#include "mozilla/AsyncEventDispatcher.h"

#include "mozilla/MappedDeclarations.h"

#include "nsAttrValueInlines.h"

#include "nsStyleConsts.h"

#include "nsMappedAttributes.h"

#include "nsContentUtils.h"

#include "nsIContentSecurityPolicy.h"

#include "nsIURI.h"

NS_IMPL_NS_NEW_HTML_ELEMENT(Shared)

namespace mozilla {

namespace dom {

extern nsAttrValue::EnumTable kListTypeTable[];

HTMLSharedElement::~HTMLSharedElement()

{

}

NS_IMPL_ELEMENT_CLONE(HTMLSharedElement)

void

HTMLSharedElement::GetHref(nsAString& aValue)

{

  MOZ_ASSERT(mNodeInfo->Equals(nsGkAtoms::base),

             "This should only get called for <base> elements");

  nsAutoString href;

  GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);

  nsCOMPtr<nsIURI> uri;

  nsIDocument* doc = OwnerDoc();

  nsContentUtils::NewURIWithDocumentCharset(

    getter_AddRefs(uri), href, doc, doc->GetFallbackBaseURI());

  if (!uri) {

    aValue = href;

    return;

  }

  nsAutoCString spec;

  uri->GetSpec(spec);

  CopyUTF8toUTF16(spec, aValue);

}

void

HTMLSharedElement::DoneAddingChildren(bool aHaveNotified)

{

  if (mNodeInfo->Equals(nsGkAtoms::head)) {

    nsCOMPtr<nsIDocument> doc = GetUncomposedDoc();

    if (doc) {

      doc->OnL10nResourceContainerParsed();

    }

    RefPtr<AsyncEventDispatcher> asyncDispatcher =

      new AsyncEventDispatcher(this,

                              NS_LITERAL_STRING("DOMHeadElementParsed"),

                              CanBubble::eYes,

                              ChromeOnlyDispatch::eYes);

    // Always run async in order to avoid running script when the content

    // sink isn't expecting it.

    asyncDispatcher->PostDOMEvent();

  }

}

bool

HTMLSharedElement::ParseAttribute(int32_t aNamespaceID,

                                  nsAtom* aAttribute,

                                  const nsAString& aValue,

                                  nsIPrincipal* aMaybeScriptedPrincipal,

                                  nsAttrValue& aResult)

{

  if (aNamespaceID == kNameSpaceID_None &&

      mNodeInfo->Equals(nsGkAtoms::dir)) {

    if (aAttribute == nsGkAtoms::type) {

      return aResult.ParseEnumValue(aValue, mozilla::dom::kListTypeTable, false);

    }

    if (aAttribute == nsGkAtoms::start) {

      return aResult.ParseIntWithBounds(aValue, 1);

    }

  }

  return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,

                                              aMaybeScriptedPrincipal, aResult);

}

static void

DirectoryMapAttributesIntoRule(const nsMappedAttributes* aAttributes,

                               MappedDeclarations& aDecls)

{

  if (!aDecls.PropertyIsSet(eCSSProperty_list_style_type)) {

    // type: enum

    const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);

    if (value) {

      if (value->Type() == nsAttrValue::eEnum) {

        aDecls.SetKeywordValue(eCSSProperty_list_style_type, value->GetEnumValue());

      } else {

        aDecls.SetKeywordValue(eCSSProperty_list_style_type, NS_STYLE_LIST_STYLE_DISC);

      }

    }

  }

  nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aDecls);

}

NS_IMETHODIMP_(bool)

HTMLSharedElement::IsAttributeMapped(const nsAtom* aAttribute) const

{

  if (mNodeInfo->Equals(nsGkAtoms::dir)) {

    static const MappedAttributeEntry attributes[] = {

      { &nsGkAtoms::type },

      // { &nsGkAtoms::compact }, // XXX

      { nullptr}

    };

    static const MappedAttributeEntry* const map[] = {

      attributes,

      sCommonAttributeMap,

    };

    return FindAttributeDependence(aAttribute, map);

  }

  return nsGenericHTMLElement::IsAttributeMapped(aAttribute);

}

static void

SetBaseURIUsingFirstBaseWithHref(nsIDocument* aDocument, nsIContent* aMustMatch)

{

  MOZ_ASSERT(aDocument, "Need a document!");

  for (nsIContent* child = aDocument->GetFirstChild(); child;

       child = child->GetNextNode()) {

    if (child->IsHTMLElement(nsGkAtoms::base) &&

        child->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::href)) {

      if (aMustMatch && child != aMustMatch) {

        return;

      }

      // Resolve the <base> element's href relative to our document's

      // fallback base URI.

      nsAutoString href;

      child->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);

      nsCOMPtr<nsIURI> newBaseURI;

      nsContentUtils::NewURIWithDocumentCharset(

        getter_AddRefs(newBaseURI), href, aDocument,

        aDocument->GetFallbackBaseURI());

      // Check if CSP allows this base-uri

      nsCOMPtr<nsIContentSecurityPolicy> csp;

      nsresult rv = aDocument->NodePrincipal()->GetCsp(getter_AddRefs(csp));

      NS_ASSERTION(NS_SUCCEEDED(rv), "Getting CSP Failed");

      // For all the different error cases we assign a nullptr to

      // newBaseURI, so we basically call aDocument->SetBaseURI(nullptr);

      if (NS_FAILED(rv)) {

        newBaseURI = nullptr;

      }

      if (csp && newBaseURI) {

        // base-uri is only enforced if explicitly defined in the

        // policy - do *not* consult default-src, see:

        // http://www.w3.org/TR/CSP2/#directive-default-src

        bool cspPermitsBaseURI = true;

        rv = csp->Permits(child->AsElement(), newBaseURI,

                          nsIContentSecurityPolicy::BASE_URI_DIRECTIVE,

                          true, &cspPermitsBaseURI);

        if (NS_FAILED(rv) || !cspPermitsBaseURI) {

          newBaseURI = nullptr;

        }

      }

      aDocument->SetBaseURI(newBaseURI);

      aDocument->SetChromeXHRDocBaseURI(nullptr);

      return;

    }

  }

  aDocument->SetBaseURI(nullptr);

}

static void

SetBaseTargetUsingFirstBaseWithTarget(nsIDocument* aDocument,

                                      nsIContent* aMustMatch)

{

  MOZ_ASSERT(aDocument, "Need a document!");

  for (nsIContent* child = aDocument->GetFirstChild(); child;

       child = child->GetNextNode()) {

    if (child->IsHTMLElement(nsGkAtoms::base) &&

        child->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::target)) {

      if (aMustMatch && child != aMustMatch) {

        return;

      }

      nsString target;

      child->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::target, target);

      aDocument->SetBaseTarget(target);

      return;

    }

  }

  aDocument->SetBaseTarget(EmptyString());

}

nsresult

HTMLSharedElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,

                                const nsAttrValue* aValue,

                                const nsAttrValue* aOldValue,

                                nsIPrincipal* aSubjectPrincipal,

                                bool aNotify)

{

  if (aNamespaceID == kNameSpaceID_None) {

    if (aName == nsGkAtoms::href) {

      // If the href attribute of a <base> tag is changing, we may need to

      // update the document's base URI, which will cause all the links on the

      // page to be re-resolved given the new base.

      // If the href is being unset (aValue is null), we will need to find a new

      // <base>.

      if (mNodeInfo->Equals(nsGkAtoms::base) && IsInUncomposedDoc()) {

        SetBaseURIUsingFirstBaseWithHref(GetUncomposedDoc(),

                                         aValue ? this : nullptr);

      }

    } else if (aName == nsGkAtoms::target) {

      // The target attribute is in pretty much the same situation as the href

      // attribute, above.

      if (mNodeInfo->Equals(nsGkAtoms::base) && IsInUncomposedDoc()) {

        SetBaseTargetUsingFirstBaseWithTarget(GetUncomposedDoc(),

                                              aValue ? this : nullptr);

      }

    }

  }

  return nsGenericHTMLElement::AfterSetAttr(aNamespaceID, aName, aValue,

                                            aOldValue, aSubjectPrincipal, aNotify);

}

nsresult

HTMLSharedElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,

                              nsIContent* aBindingParent)

{

  nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,

                                                 aBindingParent);

  NS_ENSURE_SUCCESS(rv, rv);

  // The document stores a pointer to its base URI and base target, which we may

  // need to update here.

  if (mNodeInfo->Equals(nsGkAtoms::base) &&

      aDocument) {

    if (HasAttr(kNameSpaceID_None, nsGkAtoms::href)) {

      SetBaseURIUsingFirstBaseWithHref(aDocument, this);

    }

    if (HasAttr(kNameSpaceID_None, nsGkAtoms::target)) {

      SetBaseTargetUsingFirstBaseWithTarget(aDocument, this);

    }

  }

  return NS_OK;

}

void

HTMLSharedElement::UnbindFromTree(bool aDeep, bool aNullParent)

{

  nsIDocument* doc = GetUncomposedDoc();

  nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);

  // If we're removing a <base> from a document, we may need to update the

  // document's base URI and base target

  if (doc && mNodeInfo->Equals(nsGkAtoms::base)) {

    if (HasAttr(kNameSpaceID_None, nsGkAtoms::href)) {

      SetBaseURIUsingFirstBaseWithHref(doc, nullptr);

    }

    if (HasAttr(kNameSpaceID_None, nsGkAtoms::target)) {

      SetBaseTargetUsingFirstBaseWithTarget(doc, nullptr);

    }

  }

}

nsMapRuleToAttributesFunc

HTMLSharedElement::GetAttributeMappingFunction() const

{

  if (mNodeInfo->Equals(nsGkAtoms::dir)) {

    return &DirectoryMapAttributesIntoRule;

  }

  return nsGenericHTMLElement::GetAttributeMappingFunction();

}

JSObject*

HTMLSharedElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)

{

  if (mNodeInfo->Equals(nsGkAtoms::param)) {

    return HTMLParamElement_Binding::Wrap(aCx, this, aGivenProto);

  }

  if (mNodeInfo->Equals(nsGkAtoms::base)) {

    return HTMLBaseElement_Binding::Wrap(aCx, this, aGivenProto);

  }

  if (mNodeInfo->Equals(nsGkAtoms::dir)) {

    return HTMLDirectoryElement_Binding::Wrap(aCx, this, aGivenProto);

  }

  if (mNodeInfo->Equals(nsGkAtoms::q) ||

      mNodeInfo->Equals(nsGkAtoms::blockquote)) {

    return HTMLQuoteElement_Binding::Wrap(aCx, this, aGivenProto);

  }

  if (mNodeInfo->Equals(nsGkAtoms::head)) {

    return HTMLHeadElement_Binding::Wrap(aCx, this, aGivenProto);

  }

  MOZ_ASSERT(mNodeInfo->Equals(nsGkAtoms::html));

  return HTMLHtmlElement_Binding::Wrap(aCx, this, aGivenProto);

}

} // namespace dom

} // namespace mozilla