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

content/renderer/dom_serializer_browsertest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 16 matching lines @@
 #include "net/base/filename_util.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebElementCollection.h"
+#include "third_party/WebKit/public/web/WebFrameSerializer.h"
+#include "third_party/WebKit/public/web/WebFrameSerializerClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebMetaElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
-#include "third_party/WebKit/public/web/WebPageSerializer.h"
-#include "third_party/WebKit/public/web/WebPageSerializerClient.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using blink::WebCString;
 using blink::WebData;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebMetaElement;
 using blink::WebElementCollection;
 using blink::WebFrame;
+using blink::WebFrameSerializer;
+using blink::WebFrameSerializerClient;
 using blink::WebLocalFrame;
 using blink::WebNode;
-using blink::WebPageSerializer;
-using blink::WebPageSerializerClient;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebView;
 using blink::WebVector;
 
 namespace content {
 
 bool HasDocType(const WebDocument& doc) {
   return doc.firstChild().isDocumentTypeNode();
 }
 
 class LoadObserver : public RenderViewObserver {
  public:
   LoadObserver(RenderView* render_view, const base::Closure& quit_closure)
       : RenderViewObserver(render_view),
         quit_closure_(quit_closure) {}
 
   void DidFinishLoad(blink::WebLocalFrame* frame) override {
     if (frame == render_view()->GetWebView()->mainFrame())
       quit_closure_.Run();
   }
 
  private:
   base::Closure quit_closure_;
 };
 
 class DomSerializerTests : public ContentBrowserTest,
-                           public WebPageSerializerClient {
+                           public WebFrameSerializerClient {
  public:
   DomSerializerTests() : serialization_reported_end_of_data_(false) {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kSingleProcess);
 #if defined(OS_WIN)
     // Don't want to try to create a GPU process.
     command_line->AppendSwitch(switches::kDisableGpu);
 #endif
   }
 
   void SetUpOnMainThread() override {
     render_view_routing_id_ =
         shell()->web_contents()->GetRenderViewHost()->GetRoutingID();
   }
 
   // DomSerializerDelegate.
   void didSerializeDataForFrame(const WebCString& data,
-                                PageSerializationStatus status) override {
+                                FrameSerializationStatus status) override {
     // Check finish status of current frame.
     ASSERT_FALSE(serialization_reported_end_of_data_);
 
     // Add data to corresponding frame's content.
     serialized_contents_ += data;
 
     // Current frame is completed saving, change the finish status.
-    if (status == WebPageSerializerClient::CurrentFrameIsFinished)
+    if (status == WebFrameSerializerClient::CurrentFrameIsFinished)
       serialization_reported_end_of_data_ = true;
   }
 
   RenderView* GetRenderView() {
     return RenderView::FromRoutingID(render_view_routing_id_);
   }
 
   WebView* GetWebView() {
     return GetRenderView()->GetWebView();
   }
@@ skipping 41 matching lines @@
   // Serialize DOM belonging to a frame with the specified |frame_url|.
   void SerializeDomForURL(const GURL& frame_url) {
     // Find corresponding WebFrame according to frame_url.
     WebFrame* web_frame = FindSubFrameByURL(frame_url);
     ASSERT_TRUE(web_frame != NULL);
     WebString file_path =
         base::FilePath(FILE_PATH_LITERAL("c:\\dummy.htm")).AsUTF16Unsafe();
     std::vector<std::pair<WebURL, WebString>> url_to_local_path;
     url_to_local_path.push_back(std::make_pair(WebURL(frame_url), file_path));
     // Start serializing DOM.
-    bool result = WebPageSerializer::serialize(
+    bool result = WebFrameSerializer::serialize(
         web_frame->toWebLocalFrame(),
-        static_cast<WebPageSerializerClient*>(this), url_to_local_path);
+        static_cast<WebFrameSerializerClient*>(this), url_to_local_path);
     ASSERT_TRUE(result);
   }
 
   void SerializeHTMLDOMWithDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents have document type.
     WebFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(HasDocType(doc));
     // Do serialization.
@@ skipping 32 matching lines @@
     SerializeDomForURL(xml_file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     ASSERT_EQ(original_contents, serialized_contents_);
   }
 
   void SerializeHTMLDOMWithAddingMOTWOnRenderer(
       const GURL& file_url, const std::string& original_contents) {
     // Make sure original contents does not have MOTW;
     std::string motw_declaration =
-       WebPageSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
+        WebFrameSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
     ASSERT_FALSE(motw_declaration.empty());
     // The encoding of original contents is ISO-8859-1, so we convert the MOTW
     // declaration to ASCII and search whether original contents has it or not.
     ASSERT_TRUE(std::string::npos == original_contents.find(motw_declaration));
 
     // Do serialization.
     SerializeDomForURL(file_url);
     // Make sure the serialized contents have MOTW ;
     ASSERT_TRUE(serialization_reported_end_of_data_);
     ASSERT_FALSE(std::string::npos ==
@@ skipping 125 matching lines @@
     ASSERT_TRUE(std::string(text_node.nodeValue().utf8()) == "&<>\"\'");
     // Do serialization.
     SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     // Compare the serialized contents with original contents to make sure
     // they are same.
     // Because we add MOTW when serializing DOM, so before comparison, we also
     // need to add MOTW to original_contents.
     std::string original_str =
-      WebPageSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
+        WebFrameSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
     original_str += original_contents;
     // Since WebCore now inserts a new HEAD element if there is no HEAD element
     // when creating BODY element. (Please see
     // HTMLParser::bodyCreateErrorCheck.) We need to append the HEAD content and
     // corresponding META content if we find WebCore-generated HEAD element.
     if (!doc.head().isNull()) {
       WebString encoding = web_frame->document().encoding();
       std::string htmlTag("<html>");
       std::string::size_type pos = original_str.find(htmlTag);
       ASSERT_NE(std::string::npos, pos);
       pos += htmlTag.length();
       std::string head_part("<head>");
       head_part +=
-          WebPageSerializer::generateMetaCharsetDeclaration(encoding).utf8();
+          WebFrameSerializer::generateMetaCharsetDeclaration(encoding).utf8();
       head_part += "</head>";
       original_str.insert(pos, head_part);
     }
     ASSERT_EQ(original_str, serialized_contents_);
   }
 
   void SerializeHTMLDOMWithEntitiesInAttributeValueOnRenderer() {
     base::FilePath page_file_path = GetTestFilePath(
         "dom_serializer", "dom_serializer/htmlentities_in_attribute_value.htm");
     // Get file URL. The URL is dummy URL to identify the following loading
@@ skipping 14 matching lines @@
     ASSERT_TRUE(!body_ele.isNull());
     WebString value = body_ele.getAttribute("title");
     ASSERT_TRUE(std::string(value.utf8()) == "&<>\"\'");
     // Do serialization.
     SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     // Compare the serialized contents with original contents to make sure
     // they are same.
     std::string original_str =
-        WebPageSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
+        WebFrameSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
     original_str += original_contents;
     if (!doc.isNull()) {
       WebString encoding = web_frame->document().encoding();
       std::string htmlTag("<html>");
       std::string::size_type pos = original_str.find(htmlTag);
       ASSERT_NE(std::string::npos, pos);
       pos += htmlTag.length();
       std::string head_part("<head>");
       head_part +=
-          WebPageSerializer::generateMetaCharsetDeclaration(encoding).utf8();
+          WebFrameSerializer::generateMetaCharsetDeclaration(encoding).utf8();
       head_part += "</head>";
       original_str.insert(pos, head_part);
     }
     ASSERT_EQ(original_str, serialized_contents_);
   }
 
   void SerializeHTMLDOMWithNonStandardEntitiesOnRenderer(const GURL& file_url) {
     // Get value of BODY's title attribute in DOM.
     WebFrame* web_frame = FindSubFrameByURL(file_url);
     WebDocument doc = web_frame->document();
@@ skipping 412 matching lines @@
   NavigateToURL(shell(), file_url);
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(
             &DomSerializerTests::
                 SubResourceForElementsInNonHTMLNamespaceOnRenderer,
             base::Unretained(this), file_url));
 }
 
 }  // namespace content