OOPIFs: Deduplicating MHTML parts across frames.

third_party/WebKit/Source/core/page/PageSerializer.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 66 matching lines @@
     if (isHTMLScriptElement(element))
         return true;
     if (isHTMLNoScriptElement(element))
         return true;
     return isHTMLMetaElement(element) && toHTMLMetaElement(element).computeEncoding().isValid();
 }
 
 class SerializerMarkupAccumulator : public MarkupAccumulator {
     STACK_ALLOCATED();
 public:
-    SerializerMarkupAccumulator(PageSerializer*, const Document&, WillBeHeapVector<RawPtrWillBeMember<Node>>&);
+    SerializerMarkupAccumulator(PageSerializer::Delegate&, const Document&, WillBeHeapVector<RawPtrWillBeMember<Node>>&);
     ~SerializerMarkupAccumulator() override;
 
 protected:
     void appendText(StringBuilder& out, Text&) override;
     bool shouldIgnoreAttribute(const Attribute&) override;
     void appendElement(StringBuilder& out, Element&, Namespaces*) override;
     void appendAttribute(StringBuilder& out, const Element&, const Attribute&, Namespaces*) override;
     void appendStartTag(Node&, Namespaces* = nullptr) override;
     void appendEndTag(const Element&) override;
 
 private:
     void appendAttributeValue(StringBuilder& out, const String& attributeValue);
     void appendRewrittenAttribute(
         StringBuilder& out,
         const Element&,
         const String& attributeName,
         const String& attributeValue);
 
-    PageSerializer* m_serializer;
+    PageSerializer::Delegate& m_delegate;
     RawPtrWillBeMember<const Document> m_document;
 
     // FIXME: |PageSerializer| uses |m_nodes| for collecting nodes in document
     // included into serialized text then extracts image, object, etc. The size
     // of this vector isn't small for large document. It is better to use
     // callback like functionality.
     WillBeHeapVector<RawPtrWillBeMember<Node>>& m_nodes;
 
     // Elements with links rewritten via appendAttribute method.
     WillBeHeapHashSet<RawPtrWillBeMember<const Element>> m_elementsWithRewrittenLinks;
 };
 
-SerializerMarkupAccumulator::SerializerMarkupAccumulator(PageSerializer* serializer, const Document& document, WillBeHeapVector<RawPtrWillBeMember<Node>>& nodes)
+SerializerMarkupAccumulator::SerializerMarkupAccumulator(PageSerializer::Delegate& delegate, const Document& document, WillBeHeapVector<RawPtrWillBeMember<Node>>& nodes)
     : MarkupAccumulator(ResolveAllURLs)
-    , m_serializer(serializer)
+    , m_delegate(delegate)
     , m_document(&document)
     , m_nodes(nodes)
 {
 }
 
 SerializerMarkupAccumulator::~SerializerMarkupAccumulator()
 {
 }
 
 void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text& text)
 {
     Element* parent = text.parentElement();
     if (parent && !shouldIgnoreElement(*parent))
         MarkupAccumulator::appendText(result, text);
 }
 
 bool SerializerMarkupAccumulator::shouldIgnoreAttribute(const Attribute& attribute)
 {
-    PageSerializer::Delegate* delegate = m_serializer->delegate();
-    if (delegate)
-        return delegate->shouldIgnoreAttribute(attribute);
-
-    return MarkupAccumulator::shouldIgnoreAttribute(attribute);
+    return m_delegate.shouldIgnoreAttribute(attribute);
 }
 
 void SerializerMarkupAccumulator::appendElement(StringBuilder& result, Element& element, Namespaces* namespaces)
 {
     if (!shouldIgnoreElement(element))
         MarkupAccumulator::appendElement(result, element, namespaces);
 
     // TODO(tiger): Refactor MarkupAccumulator so it is easier to append an element like this, without special cases for XHTML
     if (isHTMLHeadElement(element)) {
         result.appendLiteral("<meta http-equiv=\"Content-Type\" content=\"");
@@ skipping 14 matching lines @@
     const Element& element,
     const Attribute& attribute,
     Namespaces* namespaces)
 {
     // Check if link rewriting can affect the attribute.
     bool isLinkAttribute = element.hasLegalLinkAttribute(attribute.name());
     bool isSrcDocAttribute = isHTMLFrameElementBase(element)
         && attribute.name() == HTMLNames::srcdocAttr;
     if (isLinkAttribute || isSrcDocAttribute) {
         // Check if the delegate wants to do link rewriting for the element.
-        PageSerializer::Delegate* delegate = m_serializer->delegate();
         String newLinkForTheElement;
-        if (delegate && delegate->rewriteLink(element, newLinkForTheElement)) {
+        if (m_delegate.rewriteLink(element, newLinkForTheElement)) {
             if (isLinkAttribute) {
                 // Rewrite element links.
                 appendRewrittenAttribute(
                     out, element, attribute.name().toString(), newLinkForTheElement);
             } else {
                 ASSERT(isSrcDocAttribute);
                 // Emit src instead of srcdoc attribute for frame elements - we want the
                 // serialized subframe to use html contents from the link provided by
                 // Delegate::rewriteLink rather than html contents from srcdoc
                 // attribute.
@@ skipping 48 matching lines @@
 
 // TODO(tiger): Right now there is no support for rewriting URLs inside CSS
 // documents which leads to bugs like <https://crbug.com/251898>. Not being
 // able to rewrite URLs inside CSS documents means that resources imported from
 // url(...) statements in CSS might not work when rewriting links for the
 // "Webpage, Complete" method of saving a page. It will take some work but it
 // needs to be done if we want to continue to support non-MHTML saved pages.
 
 PageSerializer::PageSerializer(
     Vector<SerializedResource>& resources,
-    Delegate* delegate)
+    Delegate& delegate)
     : m_resources(&resources)
     , m_delegate(delegate)
 {
 }
 
 void PageSerializer::serializeFrame(const LocalFrame& frame)
 {
     ASSERT(frame.document());
     Document& document = *frame.document();
     KURL url = document.url();
 
     // If frame is an image document, add the image and don't continue
     if (document.isImageDocument()) {
         ImageDocument& imageDocument = toImageDocument(document);
         addImageToResources(imageDocument.cachedImage(), url);
         return;
     }
 
     WillBeHeapVector<RawPtrWillBeMember<Node>> serializedNodes;
-    SerializerMarkupAccumulator accumulator(this, document, serializedNodes);
+    SerializerMarkupAccumulator accumulator(m_delegate, document, serializedNodes);
     String text = serializeNodes<EditingStrategy>(accumulator, document, IncludeNode);
 
     CString frameHTML = document.encoding().encode(text, WTF::EntitiesForUnencodables);
     m_resources->append(SerializedResource(url, document.suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
 
     for (Node* node: serializedNodes) {
         ASSERT(node);
         if (!node->isElementNode())
             continue;
 
@@ skipping 14 matching lines @@
             if (inputElement.type() == InputTypeNames::image && inputElement.imageLoader()) {
                 KURL url = inputElement.src();
                 ImageResource* 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);
-                ASSERT(m_resourceURLs.contains(url));
             }
         } else if (isHTMLStyleElement(element)) {
             HTMLStyleElement& styleElement = toHTMLStyleElement(element);
             if (CSSStyleSheet* sheet = styleElement.sheet())
                 serializeCSSStyleSheet(*sheet, KURL());
         }
     }
 }
 
 void PageSerializer::serializeCSSStyleSheet(CSSStyleSheet& styleSheet, const KURL& url)
 {
     StringBuilder cssText;
     cssText.appendLiteral("@charset \"");
     cssText.append(styleSheet.contents()->charset().lower());
     cssText.appendLiteral("\";\n\n");
 
     for (unsigned i = 0; i < styleSheet.length(); ++i) {
         CSSRule* rule = styleSheet.item(i);
         String itemText = rule->cssText();
         if (!itemText.isEmpty()) {
             cssText.append(itemText);
             if (i < styleSheet.length() - 1)
                 cssText.appendLiteral("\n\n");
         }
 
         // Some rules have resources associated with them that we need to retrieve.
         serializeCSSRule(rule);
     }
 
-    if (url.isValid() && !m_resourceURLs.contains(url)) {
+    if (shouldAddURL(url)) {
         WTF::TextEncoding textEncoding(styleSheet.contents()->charset());
         ASSERT(textEncoding.isValid());
         String textString = cssText.toString();
         CString text = textEncoding.encode(textString, WTF::EntitiesForUnencodables);
         m_resources->append(SerializedResource(url, String("text/css"), SharedBuffer::create(text.data(), text.length())));
         m_resourceURLs.add(url);
     }
 }
 
 void PageSerializer::serializeCSSRule(CSSRule* rule)
@@ skipping 39 matching lines @@
     case CSSRule::VIEWPORT_RULE:
         break;
 
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 bool PageSerializer::shouldAddURL(const KURL& url)
 {
-    return url.isValid() && !m_resourceURLs.contains(url) && !url.protocolIsData();
+    return url.isValid() && !m_resourceURLs.contains(url) && !url.protocolIsData()
+        && !m_delegate.shouldSkipResource(url);
 }
 
 void PageSerializer::addToResources(Resource* resource, PassRefPtr<SharedBuffer> data, const KURL& url)
 {
     if (!data) {
         WTF_LOG_ERROR("No data for resource %s", url.string().utf8().data());
         return;
     }
 
     String mimeType = resource->response().mimeType();
@@ skipping 56 matching lines @@
         }
 
         addFontToResources(fontFaceSrcValue->fetch(&document));
     } else if (cssValue->isValueList()) {
         CSSValueList* cssValueList = toCSSValueList(cssValue);
         for (unsigned i = 0; i < cssValueList->length(); i++)
             retrieveResourcesForCSSValue(cssValueList->item(i), document);
     }
 }
 
-PageSerializer::Delegate* PageSerializer::delegate()
-{
-    return m_delegate;
-}
-
 // Returns MOTW (Mark of the Web) declaration before html tag which is in
 // HTML comment, e.g. "<!-- saved from url=(%04d)%s -->"
 // See http://msdn2.microsoft.com/en-us/library/ms537628(VS.85).aspx.
 String PageSerializer::markOfTheWebDeclaration(const KURL& url)
 {
     StringBuilder builder;
     bool emitsMinus = false;
     CString orignalUrl = url.string().ascii();
     for (const char* string = orignalUrl.data(); *string; ++string) {
         const char ch = *string;
         if (ch == '-' && emitsMinus) {
             builder.append("%2D");
             emitsMinus = false;
             continue;
         }
         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