Break StyleImage dependency on LayoutObject

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

 /*
  * Copyright (C) 2008 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 "core/layout/LayoutObject.h"
 #include "platform/graphics/Image.h"
 
 namespace blink {
 
 CSSImageGeneratorValue::CSSImageGeneratorValue(ClassType class_type)
     : CSSValue(class_type) {}
 
 CSSImageGeneratorValue::~CSSImageGeneratorValue() {}
 
-void CSSImageGeneratorValue::AddClient(const LayoutObject* layout_object,
+void CSSImageGeneratorValue::AddClient(const ImageResourceObserver* client,
                                        const IntSize& size) {
-  DCHECK(layout_object);
+  DCHECK(client);
   if (clients_.IsEmpty()) {
     DCHECK(!keep_alive_);
     keep_alive_ = this;
   }
 
   if (!size.IsEmpty())
     sizes_.insert(size);
 
-  LayoutObjectSizeCountMap::iterator it = clients_.find(layout_object);
+  ClientSizeCountMap::iterator it = clients_.find(client);
   if (it == clients_.end()) {
-    clients_.insert(layout_object, SizeAndCount(size, 1));
+    clients_.insert(client, SizeAndCount(size, 1));
   } else {
     SizeAndCount& size_count = it->value;
     ++size_count.count;
   }
 }
 
 CSSImageGeneratorValue* CSSImageGeneratorValue::ValueWithURLsMadeAbsolute() {
   if (IsCrossfadeValue())
     return ToCSSCrossfadeValue(this)->ValueWithURLsMadeAbsolute();
   return this;
 }
 
-void CSSImageGeneratorValue::RemoveClient(const LayoutObject* layout_object) {
-  DCHECK(layout_object);
-  LayoutObjectSizeCountMap::iterator it = clients_.find(layout_object);
+void CSSImageGeneratorValue::RemoveClient(const ImageResourceObserver* client) {
+  DCHECK(client);
+  ClientSizeCountMap::iterator it = clients_.find(client);
   SECURITY_DCHECK(it != clients_.end());
 
   IntSize removed_image_size;
   SizeAndCount& size_count = it->value;
   IntSize size = size_count.size;
   if (!size.IsEmpty()) {
     sizes_.erase(size);
     if (!sizes_.Contains(size))
       images_.erase(size);
   }
 
   if (!--size_count.count)
-    clients_.erase(layout_object);
+    clients_.erase(client);
 
   if (clients_.IsEmpty()) {
     DCHECK(keep_alive_);
     keep_alive_.Clear();
   }
 }
 
-Image* CSSImageGeneratorValue::GetImage(const LayoutObject* layout_object,
+Image* CSSImageGeneratorValue::GetImage(const ImageResourceObserver* client,
+                                        const Document&,
+                                        const ComputedStyle&,
                                         const IntSize& size) {
-  LayoutObjectSizeCountMap::iterator it = clients_.find(layout_object);
+  ClientSizeCountMap::iterator it = clients_.find(client);
   if (it != clients_.end()) {
     SizeAndCount& size_count = it->value;
     IntSize old_size = size_count.size;
     if (old_size != size) {
-      RemoveClient(layout_object);
-      AddClient(layout_object, size);
+      RemoveClient(client);
+      AddClient(client, size);
     }
   }
 
   // Don't generate an image for empty sizes.
   if (size.IsEmpty())
     return nullptr;
 
   // Look up the image in our cache.
   return images_.at(size);
 }
 
 void CSSImageGeneratorValue::PutImage(const IntSize& size,
                                       PassRefPtr<Image> image) {
   images_.insert(size, std::move(image));
 }
 
 PassRefPtr<Image> CSSImageGeneratorValue::GetImage(
-    const LayoutObject& layout_object,
+    const ImageResourceObserver& client,
+    const Document& document,
+    const ComputedStyle& style,
     const IntSize& size) {
   switch (GetClassType()) {
     case kCrossfadeClass:
-      return ToCSSCrossfadeValue(this)->GetImage(layout_object, size);
+      return ToCSSCrossfadeValue(this)->GetImage(client, document, style, size);
     case kLinearGradientClass:
-      return ToCSSLinearGradientValue(this)->GetImage(layout_object, size);
+      return ToCSSLinearGradientValue(this)->GetImage(client, document, style,
+                                                      size);
     case kPaintClass:
-      return ToCSSPaintValue(this)->GetImage(layout_object, size);
+      return ToCSSPaintValue(this)->GetImage(client, document, style, size);
     case kRadialGradientClass:
-      return ToCSSRadialGradientValue(this)->GetImage(layout_object, size);
+      return ToCSSRadialGradientValue(this)->GetImage(client, document, style,
+                                                      size);
     case kConicGradientClass:
-      return ToCSSConicGradientValue(this)->GetImage(layout_object, size);
+      return ToCSSConicGradientValue(this)->GetImage(client, document, style,
+                                                     size);
     default:
       NOTREACHED();
   }
   return nullptr;
 }
 
 bool CSSImageGeneratorValue::IsFixedSize() const {
   switch (GetClassType()) {
     case kCrossfadeClass:
       return ToCSSCrossfadeValue(this)->IsFixedSize();
@@ skipping 85 matching lines @@
       break;
     case kConicGradientClass:
       ToCSSConicGradientValue(this)->LoadSubimages(document);
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace blink