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

third_party/WebKit/Source/web/WebFrameSerializerImpl.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 57 matching lines @@
 // correctly loading local saved resource files. Also I think we need to inherit
 // the base target value from document object when appending new base tag.
 // If there are multiple base tags in original document, we will comment all old
 // base tags and append new base tag after each old base tag because we do not
 // know those old base tags are original content or added by JavaScript. If
 // they are added by JavaScript, it means when loading saved page, the script(s)
 // will still insert base tag(s) to DOM, so the new added base tag(s) can
 // override the incorrect base URL and make sure we alway load correct local
 // saved resource files.
 
-#include "web/WebPageSerializerImpl.h"
+#include "web/WebFrameSerializerImpl.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/frame/FrameSerializer.h"
 #include "core/html/HTMLAllCollection.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFormElement.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 {
 
 // 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.
+// contegious string is found in the html document.
 static const unsigned dataBufferCapacity = 65536;
 
-WebPageSerializerImpl::SerializeDomParam::SerializeDomParam(const KURL& url,
-                                                            const WTF::TextEncoding& textEncoding,
-                                                            Document* document)
+WebFrameSerializerImpl::SerializeDomParam::SerializeDomParam(
+    const KURL& url,
+    const WTF::TextEncoding& textEncoding,
+    Document* document)
     : url(url)
     , textEncoding(textEncoding)
     , document(document)
     , isHTMLDocument(document->isHTMLDocument())
     , haveSeenDocType(false)
     , haveAddedCharsetDeclaration(false)
     , skipMetaElement(nullptr)
     , isInScriptOrStyleTag(false)
     , haveAddedXMLProcessingDirective(false)
     , haveAddedContentsBeforeEnd(false)
 {
 }
 
-String WebPageSerializerImpl::preActionBeforeSerializeOpenTag(
+String WebFrameSerializerImpl::preActionBeforeSerializeOpenTag(
     const Element* element, SerializeDomParam* param, bool* needSkip)
 {
     StringBuilder result;
 
     *needSkip = false;
     if (param->isHTMLDocument) {
         // Skip the open tag of original META tag which declare charset since we
         // have overrided the META which have correct charset declaration after
         // serializing open tag of HEAD element.
         ASSERT(element);
         if (isHTMLMetaElement(element) && toHTMLMetaElement(element)->computeEncoding().isValid()) {
             // Found META tag declared charset, we need to skip it when
             // serializing DOM.
             param->skipMetaElement = element;
             *needSkip = true;
         } else if (isHTMLHtmlElement(*element)) {
             // Check something before processing the open tag of HEAD element.
             // First we add doc type declaration if original document has it.
             if (!param->haveSeenDocType) {
                 param->haveSeenDocType = true;
                 result.append(createMarkup(param->document->doctype()));
             }
 
             // Add MOTW declaration before html tag.
             // See http://msdn2.microsoft.com/en-us/library/ms537628(VS.85).aspx.
-            result.append(WebPageSerializer::generateMarkOfTheWebDeclaration(param->url));
+            result.append(WebFrameSerializer::generateMarkOfTheWebDeclaration(param->url));
         } else if (isHTMLBaseElement(*element)) {
             // Comment the BASE tag when serializing dom.
             result.appendLiteral("<!--");
         }
     } else {
         // Write XML declaration.
         if (!param->haveAddedXMLProcessingDirective) {
             param->haveAddedXMLProcessingDirective = true;
             // Get encoding info.
             String xmlEncoding = param->document->xmlEncoding();
@@ skipping 11 matching lines @@
         }
         // Add doc type declaration if original document has it.
         if (!param->haveSeenDocType) {
             param->haveSeenDocType = true;
             result.append(createMarkup(param->document->doctype()));
         }
     }
     return result.toString();
 }
 
-String WebPageSerializerImpl::postActionAfterSerializeOpenTag(
+String WebFrameSerializerImpl::postActionAfterSerializeOpenTag(
     const Element* element, SerializeDomParam* param)
 {
     StringBuilder result;
 
     param->haveAddedContentsBeforeEnd = false;
     if (!param->isHTMLDocument)
         return result.toString();
     // Check after processing the open tag of HEAD element
     if (!param->haveAddedCharsetDeclaration
         && isHTMLHeadElement(*element)) {
         param->haveAddedCharsetDeclaration = true;
-        // Check meta element. WebKit only pre-parse the first 512 bytes
-        // of the document. If the whole <HEAD> is larger and meta is the
-        // end of head part, then this kind of pages aren't decoded correctly
-        // because of this issue. So when we serialize the DOM, we need to
-        // make sure the meta will in first child of head tag.
+        // Check meta element. WebKit only pre-parse the first 512 bytes of the
+        // document. If the whole <HEAD> is larger and meta is the end of head
+        // part, then this kind of html documents aren't decoded correctly
+        // because of this issue. So when we serialize the DOM, we need to make
+        // sure the meta will in first child of head tag.
         // See http://bugs.webkit.org/show_bug.cgi?id=16621.
         // First we generate new content for writing correct META element.
-        result.append(WebPageSerializer::generateMetaCharsetDeclaration(
+        result.append(WebFrameSerializer::generateMetaCharsetDeclaration(
             String(param->textEncoding.name())));
 
         param->haveAddedContentsBeforeEnd = true;
         // Will search each META which has charset declaration, and skip them all
         // in PreActionBeforeSerializeOpenTag.
     } else if (isHTMLScriptElement(*element) || isHTMLScriptElement(*element)) {
         param->isInScriptOrStyleTag = true;
     }
 
     return result.toString();
 }
 
-String WebPageSerializerImpl::preActionBeforeSerializeEndTag(
+String WebFrameSerializerImpl::preActionBeforeSerializeEndTag(
     const Element* element, SerializeDomParam* param, bool* needSkip)
 {
     String result;
 
     *needSkip = false;
     if (!param->isHTMLDocument)
         return result;
     // Skip the end tag of original META tag which declare charset.
     // Need not to check whether it's META tag since we guarantee
     // skipMetaElement is definitely META tag if it's not 0.
     if (param->skipMetaElement == element) {
         *needSkip = true;
     } else if (isHTMLScriptElement(*element) || isHTMLScriptElement(*element)) {
         ASSERT(param->isInScriptOrStyleTag);
         param->isInScriptOrStyleTag = false;
     }
 
     return result;
 }
 
 // After we finish serializing end tag of a element, we give the target
 // element a chance to do some post work to add some additional data.
-String WebPageSerializerImpl::postActionAfterSerializeEndTag(
+String WebFrameSerializerImpl::postActionAfterSerializeEndTag(
     const Element* element, SerializeDomParam* param)
 {
     StringBuilder result;
 
     if (!param->isHTMLDocument)
         return result.toString();
     // Comment the BASE tag when serializing DOM.
     if (isHTMLBaseElement(*element)) {
         result.appendLiteral("-->");
         // Append a new base tag declaration.
-        result.append(WebPageSerializer::generateBaseTagDeclaration(
+        result.append(WebFrameSerializer::generateBaseTagDeclaration(
             param->document->baseTarget()));
     }
 
     return result.toString();
 }
 
-void WebPageSerializerImpl::saveHTMLContentToBuffer(
+void WebFrameSerializerImpl::saveHTMLContentToBuffer(
     const String& result, SerializeDomParam* param)
 {
     m_dataBuffer.append(result);
-    encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsNotFinished,
-                         param,
-                         DoNotForceFlush);
+    encodeAndFlushBuffer(
+        WebFrameSerializerClient::CurrentFrameIsNotFinished,
+        param,
+        DoNotForceFlush);
 }
 
-void WebPageSerializerImpl::encodeAndFlushBuffer(
-    WebPageSerializerClient::PageSerializationStatus status,
+void WebFrameSerializerImpl::encodeAndFlushBuffer(
+    WebFrameSerializerClient::FrameSerializationStatus 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.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::openTagToString(Element* element,
-                                            SerializeDomParam* param)
+void WebFrameSerializerImpl::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());
@@ skipping 40 matching lines @@
     // 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);
 }
 
 // Serialize end tag of an specified element.
-void WebPageSerializerImpl::endTagToString(Element* element,
-                                           SerializeDomParam* param)
+void WebFrameSerializerImpl::endTagToString(
+    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("</");
         result.append(element->nodeName().lower());
         result.append('>');
     } else {
         // Check whether we have to write end tag for empty element.
         if (param->isHTMLDocument) {
             result.append('>');
-            // FIXME: This code is horribly wrong.  WebPageSerializerImpl must die.
+            // FIXME: This code is horribly wrong.  WebFrameSerializerImpl must die.
             if (!element->isHTMLElement() || !toHTMLElement(element)->ieForbidsInsertHTML()) {
                 // We need to write end tag when it is required.
                 result.appendLiteral("</");
                 result.append(element->nodeName().lower());
                 result.append('>');
             }
         } else {
             // For xml base document.
             result.appendLiteral(" />");
         }
     }
     // Do post action for end tag.
     result.append(postActionAfterSerializeEndTag(element, param));
     // Save the result to data buffer.
     saveHTMLContentToBuffer(result.toString(), param);
 }
 
-void WebPageSerializerImpl::buildContentForNode(Node* node,
-                                                SerializeDomParam* param)
+void WebFrameSerializerImpl::buildContentForNode(
+    Node* node,
+    SerializeDomParam* param)
 {
     switch (node->nodeType()) {
     case Node::ELEMENT_NODE:
         // Process open tag of element.
         openTagToString(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);
@@ skipping 10 matching lines @@
     // 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(
+WebFrameSerializerImpl::WebFrameSerializerImpl(
     WebLocalFrame* frame,
-    WebPageSerializerClient* client,
+    WebFrameSerializerClient* client,
     const WebVector<std::pair<WebURL, WebString>>& urlsToLocalPaths)
     : 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.
     for (const auto& it : urlsToLocalPaths) {
         KURL url = it.first;
         ASSERT(!m_localLinks.contains(url.string()));
         m_localLinks.set(url.string(), it.second);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
 }
 
-bool WebPageSerializerImpl::serialize()
+bool WebFrameSerializerImpl::serialize()
 {
     bool didSerialization = false;
 
     Document* document = m_specifiedWebLocalFrameImpl->frame()->document();
     const KURL& url = document->url();
 
     if (url.isValid()) {
         didSerialization = true;
 
         const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
         if (textEncoding.isNonByteBasedEncoding()) {
             const UChar byteOrderMark = 0xFEFF;
             m_dataBuffer.append(byteOrderMark);
         }
 
         SerializeDomParam param(url, textEncoding, document);
 
         Element* documentElement = document->documentElement();
         if (documentElement)
             buildContentForNode(documentElement, &param);
 
-        encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, &param, ForceFlush);
+        encodeAndFlushBuffer(WebFrameSerializerClient::CurrentFrameIsFinished, &param, ForceFlush);
     } else {
         // Report empty contents for invalid URLs.
         m_client->didSerializeDataForFrame(
-            WebCString(), WebPageSerializerClient::CurrentFrameIsFinished);
+            WebCString(), WebFrameSerializerClient::CurrentFrameIsFinished);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
     return didSerialization;
 }
 
-}  // namespace blink
+} // namespace blink