third_party/WebKit/Source/core/layout/svg/SVGResourcesCache.cpp

/*
 * Copyright (C) Research In Motion Limited 2010. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "core/layout/svg/SVGResourcesCache.h"

#include "core/HTMLNames.h"
#include "core/layout/svg/LayoutSVGResourceContainer.h"
#include "core/layout/svg/SVGResources.h"
#include "core/layout/svg/SVGResourcesCycleSolver.h"
#include "core/svg/SVGDocumentExtensions.h"
#include <memory>

namespace blink {

SVGResourcesCache::SVGResourcesCache() {}

SVGResourcesCache::~SVGResourcesCache() {}

void SVGResourcesCache::addResourcesFromLayoutObject(
    LayoutObject* object,
    const ComputedStyle& style) {
  ASSERT(object);
  ASSERT(!m_cache.contains(object));

  // Build a list of all resources associated with the passed LayoutObject.
  std::unique_ptr<SVGResources> newResources =
      SVGResources::buildResources(object, style);
  if (!newResources)
    return;

  // Put object in cache.
  SVGResources* resources =
      m_cache.set(object, std::move(newResources)).storedValue->value.get();

  // Run cycle-detection _afterwards_, so self-references can be caught as well.
  SVGResourcesCycleSolver solver(object, resources);
  solver.resolveCycles();

  // Walk resources and register the layout object as a client of each resource.
  HashSet<LayoutSVGResourceContainer*> resourceSet;
  resources->buildSetOfResources(resourceSet);

  for (auto* resourceContainer : resourceSet)
    resourceContainer->addClient(object);
}

void SVGResourcesCache::removeResourcesFromLayoutObject(LayoutObject* object) {
  std::unique_ptr<SVGResources> resources = m_cache.take(object);
  if (!resources)
    return;

  // Walk resources and unregister the layout object as a client of each
  // resource.
  HashSet<LayoutSVGResourceContainer*> resourceSet;
  resources->buildSetOfResources(resourceSet);

  for (auto* resourceContainer : resourceSet)
    resourceContainer->removeClient(object);
}

static inline SVGResourcesCache& resourcesCache(Document& document) {
  return document.accessSVGExtensions().resourcesCache();
}

SVGResources* SVGResourcesCache::cachedResourcesForLayoutObject(
    const LayoutObject* layoutObject) {
  ASSERT(layoutObject);
  return resourcesCache(layoutObject->document()).m_cache.get(layoutObject);
}

void SVGResourcesCache::clientLayoutChanged(LayoutObject* object) {
  SVGResources* resources = cachedResourcesForLayoutObject(object);
  if (!resources)
    return;

  // Invalidate the resources if either the LayoutObject itself changed,
  // or we have filter resources, which could depend on the layout of children.
  if (object->selfNeedsLayout() || resources->filter())
    resources->removeClientFromCache(object);
}

static inline bool layoutObjectCanHaveResources(LayoutObject* layoutObject) {
  ASSERT(layoutObject);
  return layoutObject->node() && layoutObject->node()->isSVGElement() &&
         !layoutObject->isSVGInlineText();
}

void SVGResourcesCache::clientStyleChanged(LayoutObject* layoutObject,
                                           StyleDifference diff,
                                           const ComputedStyle& newStyle) {
  ASSERT(layoutObject);
  ASSERT(layoutObject->node());
  ASSERT(layoutObject->node()->isSVGElement());

  if (!diff.hasDifference() || !layoutObject->parent())
    return;

  // In this case the proper SVGFE*Element will decide whether the modified CSS
  // properties require
  // a relayout or paintInvalidation.
  if (layoutObject->isSVGResourceFilterPrimitive() && !diff.needsLayout())
    return;

  // Dynamic changes of CSS properties like 'clip-path' may require us to
  // recompute the associated resources for a LayoutObject.
  // TODO(fs): Avoid passing in a useless StyleDifference, but instead compare
  // oldStyle/newStyle to see which resources changed to be able to selectively
  // rebuild individual resources, instead of all of them.
  if (layoutObjectCanHaveResources(layoutObject)) {
    SVGResourcesCache& cache = resourcesCache(layoutObject->document());
    cache.removeResourcesFromLayoutObject(layoutObject);
    cache.addResourcesFromLayoutObject(layoutObject, newStyle);
  }

  LayoutSVGResourceContainer::markForLayoutAndParentResourceInvalidation(
      layoutObject, false);
}

void SVGResourcesCache::clientWasAddedToTree(LayoutObject* layoutObject,
                                             const ComputedStyle& newStyle) {
  if (!layoutObject->node())
    return;
  LayoutSVGResourceContainer::markForLayoutAndParentResourceInvalidation(
      layoutObject, false);

  if (!layoutObjectCanHaveResources(layoutObject))
    return;
  SVGResourcesCache& cache = resourcesCache(layoutObject->document());
  cache.addResourcesFromLayoutObject(layoutObject, newStyle);
}

void SVGResourcesCache::clientWillBeRemovedFromTree(
    LayoutObject* layoutObject) {
  if (!layoutObject->node())
    return;
  LayoutSVGResourceContainer::markForLayoutAndParentResourceInvalidation(
      layoutObject, false);

  if (!layoutObjectCanHaveResources(layoutObject))
    return;
  SVGResourcesCache& cache = resourcesCache(layoutObject->document());
  cache.removeResourcesFromLayoutObject(layoutObject);
}

void SVGResourcesCache::clientDestroyed(LayoutObject* layoutObject) {
  ASSERT(layoutObject);

  SVGResources* resources = cachedResourcesForLayoutObject(layoutObject);
  if (resources)
    resources->removeClientFromCache(layoutObject);
  SVGResourcesCache& cache = resourcesCache(layoutObject->document());
  cache.removeResourcesFromLayoutObject(layoutObject);
}

}  // namespace blink