Break StyleImage dependency on LayoutObject

third_party/WebKit/Source/core/css/CSSPaintValue.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/CSSPaintValue.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSSyntaxDescriptor.h"
 #include "core/css/cssom/StyleValueFactory.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 24 matching lines @@
     result.Append(variable_data.Get()->TokenRange().Serialize());
   }
   result.Append(')');
   return result.ToString();
 }
 
 String CSSPaintValue::GetName() const {
   return name_->Value();
 }
 
-PassRefPtr<Image> CSSPaintValue::GetImage(const LayoutObject& layout_object,
+PassRefPtr<Image> CSSPaintValue::GetImage(const ImageResourceObserver& client,
+                                          const Document& document,
+                                          const ComputedStyle&,
                                           const IntSize& size) {
-  if (!generator_)
-    generator_ =
-        CSSPaintImageGenerator::Create(GetName(), layout_object.GetDocument(),
-                                       paint_image_generator_observer_);
+  if (!generator_) {
+    generator_ = CSSPaintImageGenerator::Create(
+        GetName(), document, paint_image_generator_observer_);
+  }
 
   if (!ParseInputArguments())
     return nullptr;
 
-  return generator_->Paint(layout_object, size, parsed_input_arguments_);
+  return generator_->Paint(client, size, parsed_input_arguments_);
 }
 
 bool CSSPaintValue::ParseInputArguments() {
   if (input_arguments_invalid_)
     return false;
 
   if (parsed_input_arguments_ ||
       !RuntimeEnabledFeatures::CSSPaintAPIArgumentsEnabled())
     return true;
 
@@ skipping 21 matching lines @@
         StyleValueFactory::CssValueToStyleValueVector(*parsed_value));
   }
   return true;
 }
 
 void CSSPaintValue::Observer::PaintImageGeneratorReady() {
   owner_value_->PaintImageGeneratorReady();
 }
 
 void CSSPaintValue::PaintImageGeneratorReady() {
-  for (const LayoutObject* client : Clients().Keys()) {
-    const_cast<LayoutObject*>(client)->ImageChanged(
+  for (const ImageResourceObserver* client : Clients().Keys()) {
+    // TODO(ikilpatrick): We shouldn't be casting like this or mutate the layout
+    // tree from a const pointer.
+    const_cast<ImageResourceObserver*>(client)->ImageChanged(
         static_cast<WrappedImagePtr>(this));
   }
 }
 
 bool CSSPaintValue::KnownToBeOpaque(const Document&,
                                     const ComputedStyle&) const {
   return generator_ && !generator_->HasAlpha();
 }
 
 bool CSSPaintValue::Equals(const CSSPaintValue& other) const {
   return GetName() == other.GetName() &&
          CustomCSSText() == other.CustomCSSText();
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSPaintValue) {
   visitor->Trace(name_);
   visitor->Trace(generator_);
   visitor->Trace(paint_image_generator_observer_);
   visitor->Trace(parsed_input_arguments_);
   CSSImageGeneratorValue::TraceAfterDispatch(visitor);
 }
 
 }  // namespace blink