Merges the two different page serializers

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 35 matching lines @@
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
 #include "core/editing/MarkupAccumulator.h"
 #include "core/fetch/FontResource.h"
 #include "core/fetch/ImageResource.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/HTMLStyleElement.h"
+#include "core/html/ImageDocument.h"
 #include "core/html/parser/HTMLMetaCharsetParser.h"
 #include "core/frame/Frame.h"
 #include "core/page/Page.h"
 #include "core/platform/graphics/Image.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/style/StyleFetchedImage.h"
 #include "core/rendering/style/StyleImage.h"
 #include "platform/SerializedResource.h"
+#include "wtf/OwnPtr.h"

[abarth-chromium, 2013/11/14 16:55:03]

Undoubtedly one of these other headers pulls in OwnPtr.h :)

 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 static bool isCharsetSpecifyingNode(Node* node)
 {
     if (!node->isHTMLElement())
@@ skipping 24 matching lines @@
     // FIXME: We should support all frame owners including applets.
     return frameOwner.hasTagName(HTMLNames::objectTag) ? HTMLNames::dataAttr : HTMLNames::srcAttr;
 }
 
 class SerializerMarkupAccumulator : public WebCore::MarkupAccumulator {
 public:
     SerializerMarkupAccumulator(PageSerializer*, Document*, Vector<Node*>*);
     virtual ~SerializerMarkupAccumulator();
 
 protected:
-    virtual void appendText(StringBuilder& out, Text*);
-    virtual void appendElement(StringBuilder& out, Element*, Namespaces*);
-    virtual void appendCustomAttributes(StringBuilder& out, Element*, Namespaces*);
-    virtual void appendEndTag(Node*);
+    virtual void appendText(StringBuilder&, Text*) OVERRIDE;
+    virtual void appendElement(StringBuilder&, Element*, Namespaces*) OVERRIDE;
+    virtual void appendCustomAttributes(StringBuilder&, Element*, Namespaces*) OVERRIDE;
+    virtual void appendEndTag(Node*) OVERRIDE;
 
-private:
     PageSerializer* m_serializer;
     Document* m_document;
 };
 
 SerializerMarkupAccumulator::SerializerMarkupAccumulator(PageSerializer* serializer, Document* document, Vector<Node*>* nodes)
     : MarkupAccumulator(nodes, ResolveAllURLs)
     , m_serializer(serializer)
     , m_document(document)
 {
+

[abarth-chromium, 2013/11/14 16:55:03]

This blank line is not needed.

 }
 
 SerializerMarkupAccumulator::~SerializerMarkupAccumulator()
 {
 }
 
-void SerializerMarkupAccumulator::appendText(StringBuilder& out, Text* text)
+void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
 {
     Element* parent = text->parentElement();
     if (parent && !shouldIgnoreElement(parent))
-        MarkupAccumulator::appendText(out, text);
+        MarkupAccumulator::appendText(result, text);
 }
 
-void SerializerMarkupAccumulator::appendElement(StringBuilder& out, Element* element, Namespaces* namespaces)
+void SerializerMarkupAccumulator::appendElement(StringBuilder& result, Element* element, Namespaces* namespaces)
 {
     if (!shouldIgnoreElement(element))
-        MarkupAccumulator::appendElement(out, element, namespaces);
+        MarkupAccumulator::appendElement(result, element, namespaces);
 
     if (element->hasTagName(HTMLNames::headTag)) {
-        out.append("<meta charset=\"");
-        out.append(m_document->charset());
-        out.append("\">");
+        result.appendLiteral("<meta charset=\"");
+        result.append(m_document->charset());
+        if (m_document->isXHTMLDocument())
+            result.appendLiteral("\" />");
+        else
+            result.appendLiteral("\">");
     }
 
     // FIXME: For object (plugins) tags and video tag we could replace them by an image of their current contents.
 }
 
-void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, Element* element, Namespaces* namespaces)
+void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& result, Element* element, Namespaces* namespaces)
 {
     if (!element->isFrameOwnerElement())
         return;
 
     HTMLFrameOwnerElement* frameOwner = toHTMLFrameOwnerElement(element);
     Frame* frame = frameOwner->contentFrame();
     if (!frame)
         return;
 
     KURL url = frame->document()->url();
     if (url.isValid() && !url.isBlankURL())
         return;
 
     // We need to give a fake location to blank frames so they can be referenced by the serialized frame.
     url = m_serializer->urlForBlankFrame(frame);
-    appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(*frameOwner), url.string()), namespaces);
+    appendAttribute(result, element, Attribute(frameOwnerURLAttributeName(*frameOwner), url.string()), namespaces);
 }
 
 void SerializerMarkupAccumulator::appendEndTag(Node* node)
 {
     if (node->isElementNode() && !shouldIgnoreElement(toElement(node)))
         MarkupAccumulator::appendEndTag(node);
 }
 
-PageSerializer::PageSerializer(Vector<SerializedResource>* resources)
-    : m_resources(resources)
-    , m_blankFrameCounter(0)
+
+

[abarth-chromium, 2013/11/14 16:55:03]

You've got two extra blank lines here.

+class LinkChangeSerializerMarkupAccumulator : public SerializerMarkupAccumulator {
+public:
+    LinkChangeSerializerMarkupAccumulator(PageSerializer*, Document*, Vector<Node*>*, LinkLocalPathMap*, String);
+
+protected:
+    virtual void appendElement(StringBuilder&, Element*, Namespaces*) OVERRIDE;
+    virtual void appendAttribute(StringBuilder&, Element*, const Attribute&, Namespaces*) OVERRIDE;
+
+private:
+    // local_links_ include all pair of local resource path and corresponding
+    // original link.
+    LinkLocalPathMap* m_replaceLinks;
+    String m_directoryName;
+};
+
+LinkChangeSerializerMarkupAccumulator::LinkChangeSerializerMarkupAccumulator(PageSerializer* serializer, Document* document, Vector<Node*>* nodes, LinkLocalPathMap* links, String directoryName)
+    : SerializerMarkupAccumulator(serializer, document, nodes)
+    , m_replaceLinks(links)
+    , m_directoryName(directoryName)
 {
 }
 
+void LinkChangeSerializerMarkupAccumulator::appendElement(StringBuilder& result, Element* element, Namespaces* namespaces)
+{
+    // TODO: or move to append open tag / close tag

[abarth-chromium, 2013/11/14 16:55:03]

TODO -> FIXME

Also, please use complete sentences in comments.

+
+    if (element->hasTagName(HTMLNames::baseTag)) {
+        // Comment the BASE tag when serializing dom.
+        result.append("<!--");
+    } else if (element->hasTagName(HTMLNames::htmlTag)) {
+        // Add MOTW (Mark of the Web) declaration before html tag.
+        // See http://msdn2.microsoft.com/en-us/library/ms537628(VS.85).aspx.
+        result.append(String::format("\n<!-- saved from url=(%04d)%s -->\n",
+            static_cast<int>(m_document->url().string().utf8().length()),
+            m_document->url().string().utf8().data()));
+    }
+
+    SerializerMarkupAccumulator::appendElement(result, element, namespaces);
+
+    if (element->hasTagName(HTMLNames::baseTag)) {
+        // Comment the BASE tag when serializing dom.
+        result.appendLiteral("-->");
+
+        // Append a new base tag declaration.
+        result.appendLiteral("<base href=\".\"");
+        if (!m_document->baseTarget().isEmpty()) {
+            result.appendLiteral(" target=\"");
+            result.append(m_document->baseTarget());
+            result.append('"');
+        }
+        if (m_document->isXHTMLDocument())
+            result.appendLiteral(" />");
+        else
+            result.appendLiteral(">");
+    }
+}
+void LinkChangeSerializerMarkupAccumulator::appendAttribute(StringBuilder& result, Element* element, const Attribute& attribute, Namespaces* namespaces)
+{
+    if (m_replaceLinks && element->isURLAttribute(attribute)
+        && !element->isJavaScriptURLAttribute(attribute)) {
+
+        // Get the absolute link

[abarth-chromium, 2013/11/14 16:55:03]

You can remove these comments that just way what the code does.  We can
determine that by looking at the code.  Comments that explain why the code does
what it does are useful, however.

+        String completeURL = m_document->completeURL(attribute.value());
+
+        // Check whether we have local files for those link.
+        if (m_replaceLinks->contains(completeURL)) {
+            // TODO: refactor markupaccumulator, reuse code

[abarth-chromium, 2013/11/14 16:55:03]

TODO -> FIXME

+            result.append(' ');
+            result.append(attribute.name().toString());
+            result.appendLiteral("=\"");
+            if (!m_directoryName.isEmpty()) {
+                result.appendLiteral("./");
+                result.append(m_directoryName);
+                result.append('/');
+            }
+            result.append(m_replaceLinks->get(completeURL));
+            result.appendLiteral("\"");
+            return;
+        }
+    }
+    MarkupAccumulator::appendAttribute(result, element, attribute, namespaces);
+}
+
+

[abarth-chromium, 2013/11/14 16:55:03]

You've got an extra blank line here.

+PageSerializer::PageSerializer(Vector<SerializedResource>* resources, LinkLocalPathMap* urls, String directory)
+    : m_resources(resources)
+    , m_URLs(urls)
+    , m_directory(directory)
+    , m_blankFrameCounter(0)
+{
+
+}
+
 void PageSerializer::serialize(Page* page)
 {
     serializeFrame(page->mainFrame());
 }
 
 void PageSerializer::serializeFrame(Frame* frame)
 {
     Document* document = frame->document();
     KURL url = document->url();
     if (!url.isValid() || url.isBlankURL()) {
         // For blank frames we generate a fake URL so they can be referenced by their containing frame.
         url = urlForBlankFrame(frame);
     }
 
     if (m_resourceURLs.contains(url)) {
         // FIXME: We could have 2 frame with the same URL but which were dynamically changed and have now
         // different content. So we should serialize both and somehow rename the frame src in the containing
         // frame. Arg!
         return;
     }
 
+    // If frame is an image document, add the image and don't continue
+    if (document->isImageDocument()) {
+        ImageDocument* imageDocument = toImageDocument(document);
+        addImageToResources(imageDocument->cachedImage(), imageDocument->imageElement()->renderer(), url);
+        return;
+    }
+
     Vector<Node*> nodes;
-    SerializerMarkupAccumulator accumulator(this, document, &nodes);
+    WTF::OwnPtr<SerializerMarkupAccumulator> accumulator;

[abarth-chromium, 2013/11/14 16:55:03]

No need for WTF:: here.  OwnPtr has a using WTF::OwnPtr directive in the header.

+    if (m_URLs) {
+        accumulator = adoptPtr(new LinkChangeSerializerMarkupAccumulator(this, document, &nodes, m_URLs, m_directory));
+    } else {
+        accumulator = adoptPtr(new SerializerMarkupAccumulator(this, document, &nodes));
+    }

[abarth-chromium, 2013/11/14 16:55:03]

No need for { } in either branch of the if here.

+    String text = accumulator->serializeNodes(document, IncludeNode);
     WTF::TextEncoding textEncoding(document->charset());
-    CString data;
-    if (!textEncoding.isValid()) {
-        // FIXME: iframes used as images trigger this. We should deal with them correctly.
-        return;
-    }
-    String text = accumulator.serializeNodes(document, IncludeNode);
     CString frameHTML = textEncoding.normalizeAndEncode(text, WTF::EntitiesForUnencodables);
     m_resources->append(SerializedResource(url, document->suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
     m_resourceURLs.add(url);
 
     for (Vector<Node*>::iterator iter = nodes.begin(); iter != nodes.end(); ++iter) {
         Node* node = *iter;
         if (!node->isElementNode())
             continue;
 
         Element* element = toElement(node);
         // We have to process in-line style as it might contain some resources (typically background images).
-        if (element->isStyledElement())
+        if (element->isStyledElement()) {
             retrieveResourcesForProperties(element->inlineStyle(), document);
+            retrieveResourcesForProperties(element->presentationAttributeStyle(), document);
+        }
 
         if (element->hasTagName(HTMLNames::imgTag)) {
             HTMLImageElement* imageElement = toHTMLImageElement(element);
             KURL url = document->completeURL(imageElement->getAttribute(HTMLNames::srcAttr));
             ImageResource* cachedImage = imageElement->cachedImage();
             addImageToResources(cachedImage, imageElement->renderer(), url);
         } else if (element->hasTagName(HTMLNames::inputTag)) {
             HTMLInputElement* inputElement = toHTMLInputElement(element);
             if (inputElement->isImageButton() && inputElement->hasImageLoader()) {
                 KURL url = inputElement->src();
@@ skipping 70 matching lines @@
     String mimeType = resource->response().mimeType();
     m_resources->append(SerializedResource(url, mimeType, data));
     m_resourceURLs.add(url);
 }
 
 void PageSerializer::addImageToResources(ImageResource* image, RenderObject* imageRenderer, const KURL& url)
 {
     if (!shouldAddURL(url))
         return;
 
-    if (!image || image->image() == Image::nullImage())
+    if (!image->hasImage() || image->image() == Image::nullImage())
         return;
 
     RefPtr<SharedBuffer> data = imageRenderer ? image->imageForRenderer(imageRenderer)->data() : 0;
     if (!data)
         data = image->image()->data();
 
     addToResources(image, data, url);
 }
 
 void PageSerializer::addFontToResources(FontResource* font)
@@ skipping 51 matching lines @@
     if (iter != m_blankFrameURLs.end())
         return iter->value;
     String url = "wyciwyg://frame/" + String::number(m_blankFrameCounter++);
     KURL fakeURL(ParsedURLString, url);
     m_blankFrameURLs.add(frame, fakeURL);
 
     return fakeURL;
 }
 
 }
+

[abarth-chromium, 2013/11/14 16:55:03]

No need for this blank line.