third_party/WebKit/Source/core/layout/svg/SVGResources.h

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

#ifndef SVGResources_h
#define SVGResources_h

#include "wtf/Allocator.h"
#include "wtf/HashSet.h"
#include "wtf/Noncopyable.h"
#include "wtf/PtrUtil.h"
#include <memory>

namespace blink {

class ComputedStyle;
class LayoutObject;
class LayoutSVGResourceClipper;
class LayoutSVGResourceContainer;
class LayoutSVGResourceFilter;
class LayoutSVGResourceMarker;
class LayoutSVGResourceMasker;
class LayoutSVGResourcePaintServer;
class SVGElement;

// Holds a set of resources associated with a LayoutObject
class SVGResources {
  WTF_MAKE_NONCOPYABLE(SVGResources);
  USING_FAST_MALLOC(SVGResources);

 public:
  SVGResources();

  static std::unique_ptr<SVGResources> buildResources(const LayoutObject*,
                                                      const ComputedStyle&);
  void layoutIfNeeded();

  static bool supportsMarkers(const SVGElement&);

  // Ordinary resources
  LayoutSVGResourceClipper* clipper() const {
    return m_clipperFilterMaskerData ? m_clipperFilterMaskerData->clipper : 0;
  }
  LayoutSVGResourceMarker* markerStart() const {
    return m_markerData ? m_markerData->markerStart : 0;
  }
  LayoutSVGResourceMarker* markerMid() const {
    return m_markerData ? m_markerData->markerMid : 0;
  }
  LayoutSVGResourceMarker* markerEnd() const {
    return m_markerData ? m_markerData->markerEnd : 0;
  }
  LayoutSVGResourceMasker* masker() const {
    return m_clipperFilterMaskerData ? m_clipperFilterMaskerData->masker : 0;
  }

  LayoutSVGResourceFilter* filter() const {
    if (m_clipperFilterMaskerData)
      return m_clipperFilterMaskerData->filter;
    return nullptr;
  }

  // Paint servers
  LayoutSVGResourcePaintServer* fill() const {
    return m_fillStrokeData ? m_fillStrokeData->fill : 0;
  }
  LayoutSVGResourcePaintServer* stroke() const {
    return m_fillStrokeData ? m_fillStrokeData->stroke : 0;
  }

  // Chainable resources - linked through xlink:href
  LayoutSVGResourceContainer* linkedResource() const {
    return m_linkedResource;
  }

  void buildSetOfResources(HashSet<LayoutSVGResourceContainer*>&);

  // Methods operating on all cached resources
  void removeClientFromCache(LayoutObject*,
                             bool markForInvalidation = true) const;
  void resourceDestroyed(LayoutSVGResourceContainer*);

#ifndef NDEBUG
  void dump(const LayoutObject*);
#endif

 private:
  friend class SVGResourcesCycleSolver;

  bool hasResourceData() const;

  // Only used by SVGResourcesCache cycle detection logic
  void resetClipper();
  void resetFilter();
  void resetMarkerStart();
  void resetMarkerMid();
  void resetMarkerEnd();
  void resetMasker();
  void resetFill();
  void resetStroke();
  void resetLinkedResource();

  bool setClipper(LayoutSVGResourceClipper*);
  bool setFilter(LayoutSVGResourceFilter*);
  bool setMarkerStart(LayoutSVGResourceMarker*);
  bool setMarkerMid(LayoutSVGResourceMarker*);
  bool setMarkerEnd(LayoutSVGResourceMarker*);
  bool setMasker(LayoutSVGResourceMasker*);
  bool setFill(LayoutSVGResourcePaintServer*);
  bool setStroke(LayoutSVGResourcePaintServer*);
  bool setLinkedResource(LayoutSVGResourceContainer*);

  // From SVG 1.1 2nd Edition
  // clipper: 'container elements' and 'graphics elements'
  // filter:  'container elements' and 'graphics elements'
  // masker:  'container elements' and 'graphics elements'
  // -> a, circle, defs, ellipse, glyph, g, image, line, marker, mask,
  // missing-glyph, path, pattern, polygon, polyline, rect, svg, switch, symbol,
  // text, use
  struct ClipperFilterMaskerData {
    USING_FAST_MALLOC(ClipperFilterMaskerData);

   public:
    ClipperFilterMaskerData()
        : clipper(nullptr), filter(nullptr), masker(nullptr) {}

    static std::unique_ptr<ClipperFilterMaskerData> create() {
      return wrapUnique(new ClipperFilterMaskerData);
    }

    LayoutSVGResourceClipper* clipper;
    LayoutSVGResourceFilter* filter;
    LayoutSVGResourceMasker* masker;
  };

  // From SVG 1.1 2nd Edition
  // marker: line, path, polygon, polyline
  struct MarkerData {
    USING_FAST_MALLOC(MarkerData);

   public:
    MarkerData()
        : markerStart(nullptr), markerMid(nullptr), markerEnd(nullptr) {}

    static std::unique_ptr<MarkerData> create() {
      return wrapUnique(new MarkerData);
    }

    LayoutSVGResourceMarker* markerStart;
    LayoutSVGResourceMarker* markerMid;
    LayoutSVGResourceMarker* markerEnd;
  };

  // From SVG 1.1 2nd Edition
  // fill:       'shapes' and 'text content elements'
  // stroke:     'shapes' and 'text content elements'
  // -> circle, ellipse, line, path, polygon, polyline, rect, text, textPath,
  // tspan
  struct FillStrokeData {
    USING_FAST_MALLOC(FillStrokeData);

   public:
    FillStrokeData() : fill(nullptr), stroke(nullptr) {}

    static std::unique_ptr<FillStrokeData> create() {
      return wrapUnique(new FillStrokeData);
    }

    LayoutSVGResourcePaintServer* fill;
    LayoutSVGResourcePaintServer* stroke;
  };

  std::unique_ptr<ClipperFilterMaskerData> m_clipperFilterMaskerData;
  std::unique_ptr<MarkerData> m_markerData;
  std::unique_ptr<FillStrokeData> m_fillStrokeData;
  LayoutSVGResourceContainer* m_linkedResource;
};

}  // namespace blink

#endif