Rename [Web]PageSerializer[Test|Client|Impl] to ...FrameSerializer...

third_party/WebKit/Source/core/frame/FrameSerializer.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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "core/page/PageSerializer.h"
+#include "core/frame/FrameSerializer.h"
 
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/css/CSSFontFaceRule.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSImportRule.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSStyleDeclaration.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
 #include "core/editing/serializers/MarkupAccumulator.h"
 #include "core/fetch/FontResource.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/html/HTMLStyleElement.h"
 #include "core/html/ImageDocument.h"
-#include "core/page/Page.h"
 #include "core/style/StyleFetchedImage.h"
 #include "core/style/StyleImage.h"
 #include "platform/SerializedResource.h"
 #include "platform/graphics/Image.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 static bool shouldIgnoreElement(const Element& element)
 {
     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::Delegate&, const Document&, WillBeHeapVector<RawPtrWillBeMember<Node>>&);
+    SerializerMarkupAccumulator(FrameSerializer::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::Delegate& m_delegate;
+    FrameSerializer::Delegate& m_delegate;
     RawPtrWillBeMember<const Document> m_document;
 
-    // FIXME: |PageSerializer| uses |m_nodes| for collecting nodes in document
+    // FIXME: |FrameSerializer| 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::Delegate& delegate, const Document& document, WillBeHeapVector<RawPtrWillBeMember<Node>>& nodes)
+SerializerMarkupAccumulator::SerializerMarkupAccumulator(FrameSerializer::Delegate& delegate, const Document& document, WillBeHeapVector<RawPtrWillBeMember<Node>>& nodes)
     : MarkupAccumulator(ResolveAllURLs)
     , m_delegate(delegate)
     , m_document(&document)
     , m_nodes(nodes)
 {
 }
 
 SerializerMarkupAccumulator::~SerializerMarkupAccumulator()
 {
 }
@@ skipping 103 matching lines @@
     out.appendLiteral("\"");
 }
 
 // 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(
+FrameSerializer::FrameSerializer(
     Vector<SerializedResource>& resources,
     Delegate& delegate)
     : m_resources(&resources)
     , m_delegate(delegate)
 {
 }
 
-void PageSerializer::serializeFrame(const LocalFrame& frame)
+void FrameSerializer::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;
@@ skipping 37 matching lines @@
                 serializeCSSStyleSheet(*sheet, 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)
+void FrameSerializer::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 (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)
+void FrameSerializer::serializeCSSRule(CSSRule* rule)
 {
     ASSERT(rule->parentStyleSheet()->ownerDocument());
     Document& document = *rule->parentStyleSheet()->ownerDocument();
 
     switch (rule->type()) {
     case CSSRule::STYLE_RULE:
         retrieveResourcesForProperties(&toCSSStyleRule(rule)->styleRule()->properties(), document);
         break;
 
     case CSSRule::IMPORT_RULE: {
@@ skipping 27 matching lines @@
     case CSSRule::KEYFRAMES_RULE:
     case CSSRule::KEYFRAME_RULE:
     case CSSRule::VIEWPORT_RULE:
         break;
 
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
-bool PageSerializer::shouldAddURL(const KURL& url)
+bool FrameSerializer::shouldAddURL(const KURL& url)
 {
     return url.isValid() && !m_resourceURLs.contains(url) && !url.protocolIsData()
         && !m_delegate.shouldSkipResource(url);
 }
 
-void PageSerializer::addToResources(Resource* resource, PassRefPtr<SharedBuffer> data, const KURL& url)
+void FrameSerializer::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();
     m_resources->append(SerializedResource(url, mimeType, data));
     m_resourceURLs.add(url);
 }
 
-void PageSerializer::addImageToResources(ImageResource* image, const KURL& url)
+void FrameSerializer::addImageToResources(ImageResource* image, const KURL& url)
 {
     if (!shouldAddURL(url))
         return;
 
     if (!image || !image->hasImage() || image->errorOccurred())
         return;
 
     RefPtr<SharedBuffer> data = image->image()->data();
     addToResources(image, data, url);
 }
 
-void PageSerializer::addFontToResources(FontResource* font)
+void FrameSerializer::addFontToResources(FontResource* font)
 {
     if (!font || !shouldAddURL(font->url()) || !font->isLoaded() || !font->resourceBuffer())
         return;
 
     RefPtr<SharedBuffer> data(font->resourceBuffer());
 
     addToResources(font, data, font->url());
 }
 
-void PageSerializer::retrieveResourcesForProperties(const StylePropertySet* styleDeclaration, Document& document)
+void FrameSerializer::retrieveResourcesForProperties(const StylePropertySet* styleDeclaration, Document& document)
 {
     if (!styleDeclaration)
         return;
 
     // The background-image and list-style-image (for ul or ol) are the CSS properties
     // that make use of images. We iterate to make sure we include any other
     // image properties there might be.
     unsigned propertyCount = styleDeclaration->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         RefPtrWillBeRawPtr<CSSValue> cssValue = styleDeclaration->propertyAt(i).value();
         retrieveResourcesForCSSValue(cssValue.get(), document);
     }
 }
 
-void PageSerializer::retrieveResourcesForCSSValue(CSSValue* cssValue, Document& document)
+void FrameSerializer::retrieveResourcesForCSSValue(CSSValue* cssValue, Document& document)
 {
     if (cssValue->isImageValue()) {
         CSSImageValue* imageValue = toCSSImageValue(cssValue);
         if (imageValue->isCachePending())
             return;
         StyleImage* styleImage = imageValue->cachedImage();
         if (!styleImage || !styleImage->isImageResource())
             return;
 
         addImageToResources(styleImage->cachedImage(), styleImage->cachedImage()->url());
     } else if (cssValue->isFontFaceSrcValue()) {
         CSSFontFaceSrcValue* fontFaceSrcValue = toCSSFontFaceSrcValue(cssValue);
         if (fontFaceSrcValue->isLocal()) {
             return;
         }
 
         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);
     }
 }
 
 // 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)
+String FrameSerializer::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