ABANDONED: OOPIFs: Moving stitching of local paths from renderer to browser process.

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/HTMLFrameElementBase.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "public/platform/WebVector.h"
 #include "web/WebLocalFrameImpl.h"
 #include "wtf/text/TextEncoding.h"
 
 namespace blink {
 
 // Maximum length of data buffer which is used to temporary save generated
 // html content data. This is a soft limit which might be passed if a very large
 // contegious string is found in the page.
 static const unsigned dataBufferCapacity = 65536;
 
 WebPageSerializerImpl::SerializeDomParam::SerializeDomParam(const KURL& url,
                                                             const WTF::TextEncoding& textEncoding,
-                                                            Document* document,
-                                                            const String& directoryName)
+                                                            Document* document)
     : url(url)
     , textEncoding(textEncoding)
     , document(document)
-    , directoryName(directoryName)
     , isHTMLDocument(document->isHTMLDocument())
     , haveSeenDocType(false)
     , haveAddedCharsetDeclaration(false)
     , skipMetaElement(nullptr)
     , isInScriptOrStyleTag(false)
     , haveAddedXMLProcessingDirective(false)
     , haveAddedContentsBeforeEnd(false)
 {
 }
 
@@ skipping 133 matching lines @@
             param->document->baseTarget()));
     }
 
     return result.toString();
 }
 
 void WebPageSerializerImpl::saveHTMLContentToBuffer(
     const String& result, SerializeDomParam* param)
 {
     m_dataBuffer.append(result);
-    encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsNotFinished,
-                         param,
-                         DoNotForceFlush);
+    encodeAndFlushBuffer(param, DoNotForceFlush);
 }
 
 void WebPageSerializerImpl::encodeAndFlushBuffer(
-    WebPageSerializerClient::PageSerializationStatus status,
     SerializeDomParam* param,
     FlushOption flushOption)
 {
     // Data buffer is not full nor do we want to force flush.
     if (flushOption != ForceFlush && m_dataBuffer.length() <= dataBufferCapacity)
         return;
 
     String content = m_dataBuffer.toString();
     m_dataBuffer.clear();
 
     CString encodedContent = param->textEncoding.normalizeAndEncode(content, WTF::EntitiesForUnencodables);
 
     // Send result to the client.
-    m_client->didSerializeDataForFrame(param->url,
-                                       WebCString(encodedContent.data(), encodedContent.length()),
-                                       status);
+    m_client->writeHtmlFragment(WebCString(encodedContent.data(), encodedContent.length()));
 }
 
 // TODO(yosin): We should utilize |MarkupFormatter| here to share code,
 // especially escaping attribute values, done by |WebEntities| |m_htmlEntities|
 // and |m_xmlEntities|.
 void WebPageSerializerImpl::openTagToString(Element* element,
                                             SerializeDomParam* param)
 {
     bool needSkip;
     StringBuilder result;
@@ skipping 16 matching lines @@
             const 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));
                 } else {
-                    // Get the absolute link
-                    WebLocalFrameImpl* subFrame = WebLocalFrameImpl::fromFrameOwnerElement(element);
-                    String completeURL = subFrame ? subFrame->frame()->document()->url() :
-                                                    param->document->completeURL(attrValue);
-                    // Check whether we have local files for those link.
-                    if (m_localLinks.contains(completeURL)) {
-                        if (!param->directoryName.isEmpty()) {
-                            result.appendLiteral("./");
-                            result.append(param->directoryName);
-                            result.append('/');
-                        }
-                        result.append(m_htmlEntities.convertEntitiesInString(m_localLinks.get(completeURL)));
-                    } else {
-                        result.append(m_htmlEntities.convertEntitiesInString(completeURL));
-                    }
+                    saveHTMLContentToBuffer(result.toString(), param);
+                    encodeAndFlushBuffer(param, ForceFlush);
+                    result.clear();
+
+                    handleLinkAttr(element, param, attrValue);
                 }
             } else {
                 if (param->isHTMLDocument)
                     result.append(m_htmlEntities.convertEntitiesInString(attrValue));
                 else
                     result.append(m_xmlEntities.convertEntitiesInString(attrValue));
             }
         }
         result.append('\"');
     }
 
     // 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.
     saveHTMLContentToBuffer(result.toString(), param);
 }
 
+void WebPageSerializerImpl::handleLinkAttr(
+    Element* element, SerializeDomParam* param, const String& attrValue)
+{
+    if (isHTMLFrameElementBase(element)) {
+        WebFrame* subframe = WebFrame::fromFrame(
+            toHTMLFrameElementBase(element)->contentFrame());
+        m_client->writeLocalPathForSubframe(*subframe);
+    } else {
+        KURL completeURL = param->document->completeURL(attrValue);
+        m_client->writeLocalPathForSavableResource(completeURL);
+    }
+}
+
 // Serialize end tag of an specified element.
-void WebPageSerializerImpl::endTagToString(Element* element,
-                                           SerializeDomParam* param)
+void WebPageSerializerImpl::handleEndTag(
+    Element* element, SerializeDomParam* param)
 {
     bool needSkip;
     StringBuilder result;
     // Do pre action for end tag.
     result.append(preActionBeforeSerializeEndTag(element, param, &needSkip));
     if (needSkip)
         return;
     // Write end tag when element has child/children.
     if (element->hasChildren() || param->haveAddedContentsBeforeEnd) {
         result.appendLiteral("</");
@@ skipping 20 matching lines @@
     // Save the result to data buffer.
     saveHTMLContentToBuffer(result.toString(), param);
 }
 
 void WebPageSerializerImpl::buildContentForNode(Node* node,
                                                 SerializeDomParam* param)
 {
     switch (node->nodeType()) {
     case Node::ELEMENT_NODE:
         // Process open tag of element.
-        openTagToString(toElement(node), param);
+        handleOpenTag(toElement(node), param);
         // Walk through the children nodes and process it.
         for (Node *child = node->firstChild(); child; child = child->nextSibling())
             buildContentForNode(child, param);
         // Process end tag of element.
-        endTagToString(toElement(node), param);
+        handleEndTag(toElement(node), param);
         break;
     case Node::TEXT_NODE:
         saveHTMLContentToBuffer(createMarkup(node), param);
         break;
     case Node::ATTRIBUTE_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
         // Should not exist.
         ASSERT_NOT_REACHED();
         break;
     // Document type node can be in DOM?
     case Node::DOCUMENT_TYPE_NODE:
         param->haveSeenDocType = true;
     default:
         // For other type node, call default action.
         saveHTMLContentToBuffer(createMarkup(node), param);
         break;
     }
 }
 
-WebPageSerializerImpl::WebPageSerializerImpl(WebFrame* frame,
-                                             WebPageSerializerClient* client,
-                                             const WebVector<WebURL>& links,
-                                             const WebVector<WebString>& localPaths,
-                                             const WebString& localDirectoryName)
+WebPageSerializerImpl::WebPageSerializerImpl(
+    WebFrame* frame,
+    WebPageSerializerClient* client)
     : m_client(client)
-    , m_localDirectoryName(localDirectoryName)
     , 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.
-    ASSERT(links.size() == localPaths.size());
-    for (size_t i = 0; i < links.size(); i++) {
-        KURL url = links[i];
-        ASSERT(!m_localLinks.contains(url.string()));
-        m_localLinks.set(url.string(), localPaths[i]);
-    }
 
     ASSERT(m_dataBuffer.isEmpty());
 }
 
 bool WebPageSerializerImpl::serialize()
 {
     bool didSerialization = false;
     KURL mainURL = m_specifiedWebLocalFrameImpl->frame()->document()->url();
 
     WebLocalFrameImpl* webFrame = m_specifiedWebLocalFrameImpl;
     Document* document = webFrame->frame()->document();
     const KURL& url = document->url();
 
-    if (url.isValid() && m_localLinks.contains(url.string())) {
+    if (url.isValid()) {
         didSerialization = true;
 
         const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
-        String directoryName = url == mainURL ? m_localDirectoryName : "";
 
-        SerializeDomParam param(url, textEncoding, document, directoryName);
+        SerializeDomParam param(url, textEncoding, document);
 
         Element* documentElement = document->documentElement();
         if (documentElement)
             buildContentForNode(documentElement, &param);
 
-        encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, &param, ForceFlush);
+        encodeAndFlushBuffer(&param, ForceFlush);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
-    m_client->didSerializeDataForFrame(KURL(), WebCString("", 0), WebPageSerializerClient::AllFramesAreFinished);
+    m_client->endOfFrame();
     return didSerialization;
 }
 
 }  // namespace blink