OOPIFs: Deduplicating MHTML parts across frames.

third_party/WebKit/Source/web/WebPageSerializer.cpp

 /*
  * Copyright (C) 2009 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 51 matching lines @@
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringConcatenate.h"
 
 namespace blink {
 
 namespace {
 
-using ContentIDMap = WillBeHeapHashMap<RawPtrWillBeMember<Frame>, String>;
-
-class MHTMLPageSerializerDelegate final :
-    public NoBaseWillBeGarbageCollected<MHTMLPageSerializerDelegate>,
-    public PageSerializer::Delegate {
+class MHTMLPageSerializerDelegate final : public PageSerializer::Delegate {
     WTF_MAKE_NONCOPYABLE(MHTMLPageSerializerDelegate);
 public:
-    MHTMLPageSerializerDelegate(const ContentIDMap& frameToContentID);
+    explicit MHTMLPageSerializerDelegate(WebPageSerializer::MHTMLPartsGenerationDelegate&);
     bool shouldIgnoreAttribute(const Attribute&) override;
     bool rewriteLink(const Element&, String& rewrittenLink) override;
-
-#if ENABLE(OILPAN)
-    void trace(Visitor* visitor) { visitor->trace(m_frameToContentID); }
-#endif
+    bool shouldSkipResource(const KURL&) override;
 
 private:
-    const ContentIDMap& m_frameToContentID;
+    WebPageSerializer::MHTMLPartsGenerationDelegate& m_webDelegate;
 };
 
 MHTMLPageSerializerDelegate::MHTMLPageSerializerDelegate(
-    const ContentIDMap& frameToContentID)
-    : m_frameToContentID(frameToContentID)
+    WebPageSerializer::MHTMLPartsGenerationDelegate& webDelegate)
+    : m_webDelegate(webDelegate)
 {
 }
 
 bool MHTMLPageSerializerDelegate::shouldIgnoreAttribute(const Attribute& attribute)
 {
     // TODO(fgorski): Presence of srcset attribute causes MHTML to not display images, as only the value of src
     // is pulled into the archive. Discarding srcset prevents the problem. Long term we should make sure to MHTML
     // plays nicely with srcset.
     return attribute.localName() == HTMLNames::srcsetAttr;
 }
 
 bool MHTMLPageSerializerDelegate::rewriteLink(
     const Element& element,
     String& rewrittenLink)
 {
     if (!element.isFrameOwnerElement())
         return false;
 
     auto* frameOwnerElement = toHTMLFrameOwnerElement(&element);
     Frame* frame = frameOwnerElement->contentFrame();
     if (!frame)
         return false;
 
-    KURL cidURI = MHTMLParser::convertContentIDToURI(m_frameToContentID.get(frame));
+    WebString contentID = m_webDelegate.getContentID(*WebFrame::fromFrame(frame));
+    KURL cidURI = MHTMLParser::convertContentIDToURI(contentID);
     ASSERT(cidURI.isValid());
 
     if (isHTMLFrameElementBase(&element)) {
         rewrittenLink = cidURI.string();
         return true;
     }
 
     if (isHTMLObjectElement(&element)) {
         Document* doc = frameOwnerElement->contentDocument();
         bool isHandledBySerializer = doc->isHTMLDocument()
             || doc->isXHTMLDocument() || doc->isImageDocument();
         if (isHandledBySerializer) {
             rewrittenLink = cidURI.string();
             return true;
         }
     }
 
     return false;
 }
 
-ContentIDMap createFrameToContentIDMap(
-    const WebVector<std::pair<WebFrame*, WebString>>& webFrameToContentID)
+bool MHTMLPageSerializerDelegate::shouldSkipResource(const KURL& url)
 {
-    ContentIDMap result;
-    for (const auto& it : webFrameToContentID) {
-        WebFrame* webFrame = it.first;
-        const WebString& webContentID = it.second;
-
-        Frame* frame = webFrame->toImplBase()->frame();
-        String contentID(webContentID);
-
-        result.add(frame, contentID);
-    }
-    return result;
+    return m_webDelegate.shouldSkipResource(url);
 }
 
 } // namespace
 
 WebData WebPageSerializer::generateMHTMLHeader(
     const WebString& boundary, WebLocalFrame* frame)
 {
     Document* document = toWebLocalFrameImpl(frame)->frame()->document();
 
     RefPtr<SharedBuffer> buffer = SharedBuffer::create();
     MHTMLArchive::generateMHTMLHeader(
         boundary, document->title(), document->suggestedMIMEType(),
         *buffer);
     return buffer.release();
 }
 
 WebData WebPageSerializer::generateMHTMLParts(
     const WebString& boundary, WebLocalFrame* webFrame, bool useBinaryEncoding,
-    const WebVector<std::pair<WebFrame*, WebString>>& webFrameToContentID)
+    MHTMLPartsGenerationDelegate* webDelegate)
 {
+    ASSERT(webFrame);
+    ASSERT(webDelegate);
+
     // Translate arguments from public to internal blink APIs.
     LocalFrame* frame = toWebLocalFrameImpl(webFrame)->frame();
     MHTMLArchive::EncodingPolicy encodingPolicy = useBinaryEncoding
         ? MHTMLArchive::EncodingPolicy::UseBinaryEncoding
         : MHTMLArchive::EncodingPolicy::UseDefaultEncoding;
-    ContentIDMap frameToContentID = createFrameToContentIDMap(webFrameToContentID);
 
     // Serialize.
     Vector<SerializedResource> resources;
-    MHTMLPageSerializerDelegate delegate(frameToContentID);
-    PageSerializer serializer(resources, &delegate);
+    MHTMLPageSerializerDelegate coreDelegate(*webDelegate);
+    PageSerializer serializer(resources, coreDelegate);
     serializer.serializeFrame(*frame);
 
+    // Get Content-ID for the frame being serialized.
+    String frameContentID = webDelegate->getContentID(*webFrame);
+    ASSERT(!frameContentID.isEmpty());
+
     // Encode serializer's output as MHTML.
     RefPtr<SharedBuffer> output = SharedBuffer::create();
     bool isFirstResource = true;
     for (const SerializedResource& resource : resources) {
         // Frame is the 1st resource (see PageSerializer::serializeFrame doc
-        // comment). Frames need a Content-ID header.
-        String contentID = isFirstResource ? frameToContentID.get(frame) : String();
+        // comment). Frames get a Content-ID header.
+        String contentID = isFirstResource ? frameContentID : String();
 
         MHTMLArchive::generateMHTMLPart(
             boundary, contentID, encodingPolicy, resource, *output);
 
         isFirstResource = false;
     }
     return output.release();
 }
 
 WebData WebPageSerializer::generateMHTMLFooter(const WebString& boundary)
@@ skipping 31 matching lines @@
 WebString WebPageSerializer::generateBaseTagDeclaration(const WebString& baseTarget)
 {
     // TODO(yosin) We should call |PageSerializer::baseTagDeclarationOf()|.
     if (baseTarget.isEmpty())
         return String("<base href=\".\">");
     String baseString = "<base href=\".\" target=\"" + static_cast<const String&>(baseTarget) + "\">";
     return baseString;
 }
 
 } // namespace blink