Tracking filter mutation via SVGElementProxy

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

 /*
  * Copyright (C) 2011 Apple Inc. 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/BoxReflection.h"
 #include "platform/graphics/Color.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class Filter;
+class SVGResourceClient;
+class SVGElementProxy;
 
 // CSS Filters
 
 class CORE_EXPORT FilterOperation
     : public GarbageCollectedFinalized<FilterOperation> {
   WTF_MAKE_NONCOPYABLE(FilterOperation);
 
  public:
   enum OperationType {
     REFERENCE,  // url(#somefilter)
@@ skipping 70 matching lines @@
 };
 
 #define DEFINE_FILTER_OPERATION_TYPE_CASTS(thisType, operationType) \
   DEFINE_TYPE_CASTS(thisType, FilterOperation, op,                  \
                     op->type() == FilterOperation::operationType,   \
                     op.type() == FilterOperation::operationType);
 
 class CORE_EXPORT ReferenceFilterOperation : public FilterOperation {
  public:
   static ReferenceFilterOperation* create(const String& url,
-                                          const AtomicString& fragment) {
-    return new ReferenceFilterOperation(url, fragment);
+                                          SVGElementProxy& elementProxy) {
+    return new ReferenceFilterOperation(url, elementProxy);
   }
 
   bool affectsOpacity() const override { return true; }
   bool movesPixels() const override { return true; }
   FloatRect mapRect(const FloatRect&) const override;
 
   const String& url() const { return m_url; }
-  const AtomicString& fragment() const { return m_fragment; }
 
   Filter* getFilter() const { return m_filter.get(); }
   void setFilter(Filter* filter) { m_filter = filter; }
 
+  SVGElementProxy& elementProxy() const { return *m_elementProxy; }
+
+  void addClient(SVGResourceClient*);
+  void removeClient(SVGResourceClient*);
+
   DECLARE_VIRTUAL_TRACE();
 
  private:
+  ReferenceFilterOperation(const String& url, SVGElementProxy&);
+
   FilterOperation* blend(const FilterOperation* from,
                          double progress) const override {
     NOTREACHED();
     return nullptr;
   }
 
-  bool operator==(const FilterOperation& o) const override {
-    if (!isSameType(o))
-      return false;
-    const ReferenceFilterOperation* other =
-        static_cast<const ReferenceFilterOperation*>(&o);
-    return m_url == other->m_url;
-  }
-
-  ReferenceFilterOperation(const String& url, const AtomicString& fragment)
-      : FilterOperation(REFERENCE), m_url(url), m_fragment(fragment) {}
+  bool operator==(const FilterOperation&) const override;
 
   String m_url;
-  AtomicString m_fragment;
+  Member<SVGElementProxy> m_elementProxy;
   Member<Filter> m_filter;
+  unsigned m_elementProxyGeneration;

[esprehn, 2016/10/25 01:18:42]

Why do we need a generation instead of a single dirty bit? I'd prefer some
setNeedsFilterUpdate() bit check instead of incrementing counters

[fs, 2016/10/25 15:00:53]

(see similar comment in SVGElementProxy.h)

 };
 
 DEFINE_FILTER_OPERATION_TYPE_CASTS(ReferenceFilterOperation, REFERENCE);
 
 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color
 // matrix effect.  For HUE_ROTATE, the angle of rotation is stored in m_amount.
 class CORE_EXPORT BasicColorMatrixFilterOperation : public FilterOperation {
  public:
   static BasicColorMatrixFilterOperation* create(double amount,
                                                  OperationType type) {
@@ skipping 174 matching lines @@
   BoxReflectFilterOperation(const BoxReflection& reflection)
       : FilterOperation(BOX_REFLECT), m_reflection(reflection) {}
 
   BoxReflection m_reflection;
 };
 DEFINE_FILTER_OPERATION_TYPE_CASTS(BoxReflectFilterOperation, BOX_REFLECT);
 
 }  // namespace blink
 
 #endif  // FilterOperation_h