Move the BreakCycle() method from the cycle solver to SVGResources

third_party/WebKit/Source/core/layout/svg/SVGResources.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
@@ skipping 400 matching lines @@
       if (!clipper_filter_masker_data_)
         break;
       if (clipper_filter_masker_data_->clipper == resource)
         clipper_filter_masker_data_->clipper = nullptr;
       break;
     default:
       NOTREACHED();
   }
 }
 
+void SVGResources::ClearReferencesTo(LayoutSVGResourceContainer* resource) {
+  DCHECK(resource);
+  if (linked_resource_ == resource) {
+    DCHECK(!clipper_filter_masker_data_);
+    DCHECK(!marker_data_);
+    DCHECK(!fill_stroke_data_);
+    linked_resource_ = nullptr;
+    return;
+  }
+
+  switch (resource->ResourceType()) {
+    case kMaskerResourceType:
+      DCHECK(clipper_filter_masker_data_);
+      DCHECK_EQ(clipper_filter_masker_data_->masker, resource);
+      clipper_filter_masker_data_->masker = nullptr;
+      break;
+    case kMarkerResourceType:
+      DCHECK(marker_data_);
+      DCHECK(resource == MarkerStart() || resource == MarkerMid() ||
+             resource == MarkerEnd());
+      if (marker_data_->marker_start == resource)
+        marker_data_->marker_start = nullptr;
+      if (marker_data_->marker_mid == resource)
+        marker_data_->marker_mid = nullptr;
+      if (marker_data_->marker_end == resource)
+        marker_data_->marker_end = nullptr;
+      break;
+    case kPatternResourceType:
+    case kLinearGradientResourceType:
+    case kRadialGradientResourceType:
+      DCHECK(fill_stroke_data_);
+      DCHECK(resource == Fill() || resource == Stroke());
+      if (fill_stroke_data_->fill == resource)
+        fill_stroke_data_->fill = nullptr;
+      if (fill_stroke_data_->stroke == resource)
+        fill_stroke_data_->stroke = nullptr;
+      break;
+    case kFilterResourceType:
+      DCHECK(clipper_filter_masker_data_);
+      DCHECK_EQ(clipper_filter_masker_data_->filter, resource);
+      clipper_filter_masker_data_->filter = nullptr;
+      break;
+    case kClipperResourceType:
+      DCHECK(clipper_filter_masker_data_);
+      DCHECK_EQ(clipper_filter_masker_data_->clipper, resource);
+      clipper_filter_masker_data_->clipper = nullptr;
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
 void SVGResources::BuildSetOfResources(
     HashSet<LayoutSVGResourceContainer*>& set) {
   if (!HasResourceData())
     return;
 
   if (linked_resource_) {
     DCHECK(!clipper_filter_masker_data_);
     DCHECK(!marker_data_);
     DCHECK(!fill_stroke_data_);
     set.insert(linked_resource_);
@@ skipping 31 matching lines @@
     return;
 
   DCHECK_EQ(clipper->ResourceType(), kClipperResourceType);
 
   if (!clipper_filter_masker_data_)
     clipper_filter_masker_data_ = ClipperFilterMaskerData::Create();
 
   clipper_filter_masker_data_->clipper = clipper;
 }
 
-void SVGResources::ResetClipper() {
-  DCHECK(clipper_filter_masker_data_);
-  DCHECK(clipper_filter_masker_data_->clipper);
-  clipper_filter_masker_data_->clipper = nullptr;
-}
-
 void SVGResources::SetFilter(LayoutSVGResourceFilter* filter) {
   if (!filter)
     return;
 
   DCHECK_EQ(filter->ResourceType(), kFilterResourceType);
 
   if (!clipper_filter_masker_data_)
     clipper_filter_masker_data_ = ClipperFilterMaskerData::Create();
 
   clipper_filter_masker_data_->filter = filter;
 }
 
-void SVGResources::ResetFilter() {
-  DCHECK(clipper_filter_masker_data_);
-  DCHECK(clipper_filter_masker_data_->filter);
-  clipper_filter_masker_data_->filter = nullptr;
-}
-
 void SVGResources::SetMarkerStart(LayoutSVGResourceMarker* marker_start) {
   if (!marker_start)
     return;
 
   DCHECK_EQ(marker_start->ResourceType(), kMarkerResourceType);
 
   if (!marker_data_)
     marker_data_ = MarkerData::Create();
 
   marker_data_->marker_start = marker_start;
 }
 
-void SVGResources::ResetMarkerStart() {
-  DCHECK(marker_data_);
-  DCHECK(marker_data_->marker_start);
-  marker_data_->marker_start = nullptr;
-}
-
 void SVGResources::SetMarkerMid(LayoutSVGResourceMarker* marker_mid) {
   if (!marker_mid)
     return;
 
   DCHECK_EQ(marker_mid->ResourceType(), kMarkerResourceType);
 
   if (!marker_data_)
     marker_data_ = MarkerData::Create();
 
   marker_data_->marker_mid = marker_mid;
 }
 
-void SVGResources::ResetMarkerMid() {
-  DCHECK(marker_data_);
-  DCHECK(marker_data_->marker_mid);
-  marker_data_->marker_mid = nullptr;
-}
-
 void SVGResources::SetMarkerEnd(LayoutSVGResourceMarker* marker_end) {
   if (!marker_end)
     return;
 
   DCHECK_EQ(marker_end->ResourceType(), kMarkerResourceType);
 
   if (!marker_data_)
     marker_data_ = MarkerData::Create();
 
   marker_data_->marker_end = marker_end;
 }
 
-void SVGResources::ResetMarkerEnd() {
-  DCHECK(marker_data_);
-  DCHECK(marker_data_->marker_end);
-  marker_data_->marker_end = nullptr;
-}
-
 void SVGResources::SetMasker(LayoutSVGResourceMasker* masker) {
   if (!masker)
     return;
 
   DCHECK_EQ(masker->ResourceType(), kMaskerResourceType);
 
   if (!clipper_filter_masker_data_)
     clipper_filter_masker_data_ = ClipperFilterMaskerData::Create();
 
   clipper_filter_masker_data_->masker = masker;
 }
 
-void SVGResources::ResetMasker() {
-  DCHECK(clipper_filter_masker_data_);
-  DCHECK(clipper_filter_masker_data_->masker);
-  clipper_filter_masker_data_->masker = nullptr;
-}
-
 void SVGResources::SetFill(LayoutSVGResourcePaintServer* fill) {
   if (!fill)
     return;
 
   if (!fill_stroke_data_)
     fill_stroke_data_ = FillStrokeData::Create();
 
   fill_stroke_data_->fill = fill;
 }
 
-void SVGResources::ResetFill() {
-  DCHECK(fill_stroke_data_);
-  DCHECK(fill_stroke_data_->fill);
-  fill_stroke_data_->fill = nullptr;
-}
-
 void SVGResources::SetStroke(LayoutSVGResourcePaintServer* stroke) {
   if (!stroke)
     return;
 
   if (!fill_stroke_data_)
     fill_stroke_data_ = FillStrokeData::Create();
 
   fill_stroke_data_->stroke = stroke;
 }
 
-void SVGResources::ResetStroke() {
-  DCHECK(fill_stroke_data_);
-  DCHECK(fill_stroke_data_->stroke);
-  fill_stroke_data_->stroke = nullptr;
-}
-
 void SVGResources::SetLinkedResource(
     LayoutSVGResourceContainer* linked_resource) {
   if (!linked_resource)
     return;
 
   linked_resource_ = linked_resource;
 }
 
-void SVGResources::ResetLinkedResource() {
-  DCHECK(linked_resource_);
-  linked_resource_ = nullptr;
-}
-
 #ifndef NDEBUG
 void SVGResources::Dump(const LayoutObject* object) {
   DCHECK(object);
   DCHECK(object->GetNode());
 
   fprintf(stderr, "-> this=%p, SVGResources(layoutObject=%p, node=%p)\n", this,
           object, object->GetNode());
   fprintf(stderr, " | DOM Tree:\n");
   fprintf(stderr, "%s", object->GetNode()->ToTreeStringForThis().Utf8().Data());
 
@@ skipping 32 matching lines @@
               stroke->GetElement());
   }
 
   if (linked_resource_)
     fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", linked_resource_,
             linked_resource_->GetElement());
 }
 #endif
 
 }  // namespace blink