Save-Page-As-Complete-Html: Each frame links to a distinct local file.

third_party/WebKit/Source/web/WebPageSerializerImpl.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 68 matching lines @@
 #include "web/WebPageSerializerImpl.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/html/HTMLAllCollection.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFormElement.h"
+#include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/PageSerializer.h"
 #include "public/platform/WebVector.h"
 #include "web/WebLocalFrameImpl.h"
 #include "wtf/text/TextEncoding.h"
 
 namespace blink {
@@ skipping 173 matching lines @@
 
     CString encodedContent = param->textEncoding.encode(content, WTF::EntitiesForUnencodables);
 
     // Send result to the client.
     m_client->didSerializeDataForFrame(WebCString(encodedContent), status);
 }
 
 // TODO(yosin): We should utilize |MarkupFormatter| here to share code,
 // especially escaping attribute values, done by |WebEntities| |m_htmlEntities|
 // and |m_xmlEntities|.
+void WebPageSerializerImpl::appendAttribute(
+    StringBuilder& result,
+    bool isHTMLDocument,
+    const String& attrName,
+    const String& attrValue) {
+    result.append(' ');
+    result.append(attrName);
+    result.appendLiteral("=\"");
+    if (isHTMLDocument)
+        result.append(m_htmlEntities.convertEntitiesInString(attrValue));
+    else
+        result.append(m_xmlEntities.convertEntitiesInString(attrValue));
+    result.append('\"');
+}
+
 void WebPageSerializerImpl::openTagToString(Element* element,
                                             SerializeDomParam* param)
 {
     bool needSkip;
     StringBuilder result;
     // Do pre action for open tag.
     result.append(preActionBeforeSerializeOpenTag(element, param, &needSkip));
     if (needSkip)
         return;
     // Add open tag
     result.append('<');
     result.append(element->nodeName().lower());
+
+    // Find out if this element owns a frame.
+    Frame* frame = nullptr;
+    if (element->isFrameOwnerElement()) {
+        frame = toHTMLFrameOwnerElement(element)->contentFrame();

[Łukasz Anforowicz, 2015/12/16 21:39:02]

There is some risk that this toHTMLFrameOwnerElement might blow-up in a way
similar to crbug.com/570073...  I can't repro this bug locally, but I am not
sure about if the predicate below is really correct (as my usage of
HTMLFrameOwnerElement is agnostic to local-vs-remote distinction):

  HTMLFrameOwnerElement.h:
    DEFINE_TYPE_CASTS(HTMLFrameOwnerElement, ..., owner->isLocal()... 

+    }
+
     // Go through all attributes and serialize them.
-    AttributeCollection attributes = element->attributes();
-    AttributeCollection::iterator end = attributes.end();
-    for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
-        result.append(' ');
-        // Add attribute pair
-        result.append(it->name().toString());
-        result.appendLiteral("=\"");
-        if (!it->value().isEmpty()) {
-            const String& attrValue = it->value();
+    for (const auto& it : element->attributes()) {
+        const QualifiedName& attrName = it.name();
+        String attrValue = it.value();
 
-            // Check whether we need to replace some resource links
-            // with local resource paths.
-            const QualifiedName& attrName = it->name();
-            if (element->hasLegalLinkAttribute(attrName)) {
-                // For links start with "javascript:", we do not change it.
-                if (attrValue.startsWith("javascript:", TextCaseInsensitive)) {
-                    result.append(m_htmlEntities.convertEntitiesInString(attrValue));
+        // Rewrite the attribute value if requested.
+        if (element->hasLegalLinkAttribute(attrName)) {
+            // For links start with "javascript:", we do not change it.
+            if (!attrValue.startsWith("javascript:", TextCaseInsensitive)) {
+                // Get the absolute link.
+                String completeURL = param->document->completeURL(attrValue);
+
+                // Check whether we have a local file to link to.
+                if (frame && m_frameToLocalPath.contains(frame)) {
+                    attrValue = m_frameToLocalPath.get(frame);
+                } else if (m_urlToLocalPath.contains(completeURL)) {
+                    attrValue = m_urlToLocalPath.get(completeURL);
                 } else {
-                    // Get the absolute link
-                    String completeURL = param->document->completeURL(attrValue);
-                    // Check whether we have local files for those link.
-                    if (m_localLinks.contains(completeURL)) {
-                        result.append(m_htmlEntities.convertEntitiesInString(m_localLinks.get(completeURL)));
-                    } else {
-                        result.append(m_htmlEntities.convertEntitiesInString(completeURL));
-                    }
+                    attrValue = completeURL;
                 }
-            } else {
-                if (param->isHTMLDocument)
-                    result.append(m_htmlEntities.convertEntitiesInString(attrValue));
-                else
-                    result.append(m_xmlEntities.convertEntitiesInString(attrValue));
             }
         }
-        result.append('\"');
+
+        appendAttribute(result, param->isHTMLDocument, attrName.toString(), attrValue);
     }
 
     // Do post action for open tag.
     String addedContents = postActionAfterSerializeOpenTag(element, param);
     // Complete the open tag for element when it has child/children.
     if (element->hasChildren() || param->haveAddedContentsBeforeEnd)
         result.append('>');
     // Append the added contents generate in  post action of open tag.
     result.append(addedContents);
     // Save the result to data buffer.
@@ skipping 65 matching lines @@
     default:
         // For other type node, call default action.
         saveHTMLContentToBuffer(createMarkup(node), param);
         break;
     }
 }
 
 WebPageSerializerImpl::WebPageSerializerImpl(
     WebLocalFrame* frame,
     WebPageSerializerClient* client,
-    const WebVector<std::pair<WebURL, WebString>>& urlsToLocalPaths)
+    const WebVector<std::pair<WebURL, WebString>>& urlsToLocalPaths,
+    const WebVector<std::pair<WebFrame*, WebString>>& framesToLocalPaths)
     : m_client(client)
     , m_htmlEntities(false)
     , m_xmlEntities(true)
 {
     // Must specify available webframe.
     ASSERT(frame);
     m_specifiedWebLocalFrameImpl = toWebLocalFrameImpl(frame);
     // Make sure we have non 0 client.
     ASSERT(client);
-    // Build local resources map.
+    // Build url to local path map.
     for (const auto& it : urlsToLocalPaths) {
         KURL url = it.first;
-        ASSERT(!m_localLinks.contains(url.string()));
-        m_localLinks.set(url.string(), it.second);
+        ASSERT(!m_urlToLocalPath.contains(url.string()));
+        m_urlToLocalPath.set(url.string(), it.second);
+    }
+    // Build frame to local path map.
+    for (const auto& it : framesToLocalPaths) {
+        WebFrame* webFrame = it.first;
+        ASSERT(webFrame);
+        Frame* frame = webFrame->toImplBase()->frame();
+        ASSERT(!m_frameToLocalPath.contains(frame));
+        m_frameToLocalPath.set(frame, it.second);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
 }
 
 bool WebPageSerializerImpl::serialize()
 {
     bool didSerialization = false;
 
     Document* document = m_specifiedWebLocalFrameImpl->frame()->document();
@@ skipping 19 matching lines @@
         // Report empty contents for invalid URLs.
         m_client->didSerializeDataForFrame(
             WebCString(), WebPageSerializerClient::CurrentFrameIsFinished);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
     return didSerialization;
 }
 
 }  // namespace blink