Use an SVGElementProxy in ReferenceClipPathOperation

third_party/WebKit/Source/core/style/ClipPathOperation.h

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 13 matching lines @@
  * 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 ClipPathOperation_h
 #define ClipPathOperation_h
 
 #include "core/style/BasicShapes.h"
+#include "core/svg/SVGElementProxy.h"
 #include "platform/graphics/Path.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefCounted.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace blink {
 
+class SVGResourceClient;
+
 class ClipPathOperation : public RefCounted<ClipPathOperation> {
  public:
   enum OperationType { REFERENCE, SHAPE };
 
   virtual ~ClipPathOperation() {}
 
   virtual bool operator==(const ClipPathOperation&) const = 0;
   bool operator!=(const ClipPathOperation& o) const { return !(*this == o); }
 
   virtual OperationType type() const = 0;
   bool isSameType(const ClipPathOperation& o) const {
     return o.type() == type();
   }
 
  protected:
   ClipPathOperation() {}
 };
 
 class ReferenceClipPathOperation final : public ClipPathOperation {
  public:
   static PassRefPtr<ReferenceClipPathOperation> create(
       const String& url,
-      const AtomicString& fragment) {
-    return adoptRef(new ReferenceClipPathOperation(url, fragment));
+      SVGElementProxy& elementProxy) {
+    return adoptRef(new ReferenceClipPathOperation(url, elementProxy));
   }
 
+  void addClient(SVGResourceClient*);
+  void removeClient(SVGResourceClient*);
+
+  SVGElementProxy& elementProxy() const { return *m_elementProxy; }
+
   const String& url() const { return m_url; }
-  const AtomicString& fragment() const { return m_fragment; }
 
  private:
-  bool operator==(const ClipPathOperation& o) const override {
-    return isSameType(o) &&
-           m_url == static_cast<const ReferenceClipPathOperation&>(o).m_url;
-  }
+  bool operator==(const ClipPathOperation&) const override;
   OperationType type() const override { return REFERENCE; }
 
-  ReferenceClipPathOperation(const String& url, const AtomicString& fragment)
-      : m_url(url), m_fragment(fragment) {}
+  ReferenceClipPathOperation(const String& url, SVGElementProxy& elementProxy)
+      : m_elementProxy(&elementProxy), m_url(url) {}
 
+  Persistent<SVGElementProxy> m_elementProxy;
   String m_url;
-  AtomicString m_fragment;
 };
 
 DEFINE_TYPE_CASTS(ReferenceClipPathOperation,
                   ClipPathOperation,
                   op,
                   op->type() == ClipPathOperation::REFERENCE,
                   op.type() == ClipPathOperation::REFERENCE);
 
 class ShapeClipPathOperation final : public ClipPathOperation {
  public:
@@ skipping 35 matching lines @@
     return false;
   BasicShape* otherShape = toShapeClipPathOperation(o).m_shape.get();
   if (!m_shape.get() || !otherShape)
     return static_cast<bool>(m_shape.get()) == static_cast<bool>(otherShape);
   return *m_shape == *otherShape;
 }
 
 }  // namespace blink
 
 #endif  // ClipPathOperation_h