[ImageResource 4] Split ImageResource into Resource and Image parts

third_party/WebKit/Source/core/frame/FrameSerializer.cpp

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 29 matching lines @@
 #include "core/css/CSSStyleDeclaration.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
 #include "core/editing/serializers/MarkupAccumulator.h"
-#include "core/fetch/ImageResource.h"
+#include "core/fetch/ImageResourceContent.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/html/HTMLStyleElement.h"
 #include "core/html/ImageDocument.h"
 #include "core/loader/resource/FontResource.h"
 #include "core/style/StyleFetchedImage.h"
@@ skipping 238 matching lines @@
     if (element.isStyledElement()) {
       retrieveResourcesForProperties(element.inlineStyle(), document);
       retrieveResourcesForProperties(element.presentationAttributeStyle(),
                                      document);
     }
 
     if (isHTMLImageElement(element)) {
       HTMLImageElement& imageElement = toHTMLImageElement(element);
       KURL url =
           document.completeURL(imageElement.getAttribute(HTMLNames::srcAttr));
-      ImageResource* cachedImage = imageElement.cachedImage();
+      ImageResourceContent* cachedImage = imageElement.cachedImage();
       addImageToResources(cachedImage, url);
     } else if (isHTMLInputElement(element)) {
       HTMLInputElement& inputElement = toHTMLInputElement(element);
       if (inputElement.type() == InputTypeNames::image &&
           inputElement.imageLoader()) {
         KURL url = inputElement.src();
-        ImageResource* cachedImage = inputElement.imageLoader()->image();
+        ImageResourceContent* cachedImage = inputElement.imageLoader()->image();
         addImageToResources(cachedImage, url);
       }
     } else if (isHTMLLinkElement(element)) {
       HTMLLinkElement& linkElement = toHTMLLinkElement(element);
       if (CSSStyleSheet* sheet = linkElement.sheet()) {
         KURL url =
             document.completeURL(linkElement.getAttribute(HTMLNames::hrefAttr));
         serializeCSSStyleSheet(*sheet, url);
       }
     } else if (isHTMLStyleElement(element)) {
@@ skipping 113 matching lines @@
     case CSSRule::kViewportRule:
       break;
   }
 }
 
 bool FrameSerializer::shouldAddURL(const KURL& url) {
   return url.isValid() && !m_resourceURLs.contains(url) &&
          !url.protocolIsData() && !m_delegate.shouldSkipResourceWithURL(url);
 }
 
-void FrameSerializer::addToResources(const Resource& resource,
+void FrameSerializer::addToResources(const String& mimeType,
+                                     bool hasCacheControlNoStoreHeader,
                                      PassRefPtr<const SharedBuffer> data,
                                      const KURL& url) {
-  if (m_delegate.shouldSkipResource(resource))
+  if (m_delegate.shouldSkipResource(hasCacheControlNoStoreHeader))
     return;
 
   if (!data) {
     DLOG(ERROR) << "No data for resource " << url.getString();
     return;
   }
 
-  String mimeType = resource.response().mimeType();
   m_resources->append(SerializedResource(url, mimeType, std::move(data)));
   m_resourceURLs.add(url);
 }
 
-void FrameSerializer::addImageToResources(ImageResource* image,
+void FrameSerializer::addImageToResources(ImageResourceContent* image,
                                           const KURL& url) {
   if (!image || !image->hasImage() || image->errorOccurred() ||
       !shouldAddURL(url))
     return;
 
   TRACE_EVENT2("page-serialization", "FrameSerializer::addImageToResources",
                "type", "image", "url", url.elidedString().utf8().data());
   double imageStartTime = monotonicallyIncreasingTime();
 
   RefPtr<const SharedBuffer> data = image->getImage()->data();
-  addToResources(*image, data, url);
+  addToResources(image->response().mimeType(),
+                 image->hasCacheControlNoStoreHeader(), data, url);
 
   // If we're already reporting time for CSS serialization don't report it for
   // this image to avoid reporting the same time twice.
   if (!m_isSerializingCss) {
     DEFINE_STATIC_LOCAL(CustomCountHistogram, imageHistogram,
                         ("PageSerialization.SerializationTime.ImageElement", 0,
                          maxSerializationTimeUmaMicroseconds, 50));
     imageHistogram.count(
         static_cast<int64_t>((monotonicallyIncreasingTime() - imageStartTime) *
                              secondsToMicroseconds));
   }
 }
 
 void FrameSerializer::addFontToResources(FontResource* font) {
   if (!font || !font->isLoaded() || !font->resourceBuffer() ||
       !shouldAddURL(font->url()))
     return;
 
   RefPtr<const SharedBuffer> data(font->resourceBuffer());
 
-  addToResources(*font, data, font->url());
+  addToResources(font->response().mimeType(),
+                 font->hasCacheControlNoStoreHeader(), data, font->url());
 }
 
 void FrameSerializer::retrieveResourcesForProperties(
     const StylePropertySet* styleDeclaration,
     Document& document) {
   if (!styleDeclaration)
     return;
 
   // The background-image and list-style-image (for ul or ol) are the CSS
   // properties that make use of images. We iterate to make sure we include any
@@ skipping 49 matching lines @@
     emitsMinus = ch == '-';
     builder.append(ch);
   }
   CString escapedUrl = builder.toString().ascii();
   return String::format("saved from url=(%04d)%s",
                         static_cast<int>(escapedUrl.length()),
                         escapedUrl.data());
 }
 
 }  // namespace blink