Remove "recursive" parameter from WebPageSerializer::serialize.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 242 matching lines @@
       WebFrame* web_frame = GetMainFrame();
 
       ASSERT_TRUE(web_frame != NULL);
 
       web_frame->loadData(data, "text/html", encoding_info, base_url);
     }
 
     runner->Run();
   }
 
-  // Serialize page DOM according to specific page URL. The parameter
-  // recursive_serialization indicates whether we will serialize all
-  // sub-frames.
-  void SerializeDomForURL(const GURL& page_url,
-                          bool recursive_serialization) {
-    // Find corresponding WebFrame according to page_url.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), page_url);
+  // 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(GetWebView(), frame_url);
     ASSERT_TRUE(web_frame != NULL);
     WebVector<WebURL> links;
-    links.assign(&page_url, 1);
+    links.assign(&frame_url, 1);
     WebString file_path =
         base::FilePath(FILE_PATH_LITERAL("c:\\dummy.htm")).AsUTF16Unsafe();
     WebVector<WebString> local_paths;
     local_paths.assign(&file_path, 1);
     // Start serializing DOM.
     bool result = WebPageSerializer::serialize(web_frame->toWebLocalFrame(),
-       recursive_serialization,
        static_cast<WebPageSerializerClient*>(this),
        links,
        local_paths,
        local_directory_name_.AsUTF16Unsafe());
     ASSERT_TRUE(result);
     ASSERT_TRUE(serialized_);
   }
 
   void SerializeHTMLDOMWithDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents have document type.
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(HasDocType(doc));
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Load the serialized contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
     // Make sure serialized contents still have document type.
     web_frame = GetMainFrame();
     doc = web_frame->document();
     ASSERT_TRUE(HasDocType(doc));
   }
 
   void SerializeHTMLDOMWithoutDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents do not have document type.
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(!HasDocType(doc));
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Load the serialized contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
     // Make sure serialized contents do not have document type.
     web_frame = GetMainFrame();
     doc = web_frame->document();
     ASSERT_TRUE(!HasDocType(doc));
   }
 
   void SerializeXMLDocWithBuiltInEntitiesOnRenderer(
       const GURL& xml_file_url, const std::string& original_contents) {
     // Do serialization.
-    SerializeDomForURL(xml_file_url, false);
+    SerializeDomForURL(xml_file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(HasSerializedFrame(xml_file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(xml_file_url);
     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();
     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, false);
+    SerializeDomForURL(file_url);
     // Make sure the serialized contents have MOTW ;
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     ASSERT_FALSE(std::string::npos ==
         serialized_contents.find(motw_declaration));
   }
 
   void SerializeHTMLDOMWithNoMetaCharsetInOriginalDocOnRenderer(
       const GURL& file_url) {
     // Make sure there is no META charset declaration in original document.
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement head_element = doc.head();
     ASSERT_TRUE(!head_element.isNull());
     // Go through all children of HEAD element.
     for (WebNode child = head_element.firstChild(); !child.isNull();
          child = child.nextSibling()) {
       std::string charset_info;
       if (IsMetaElement(child, charset_info))
         ASSERT_TRUE(charset_info.empty());
     }
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
 
     // Load the serialized contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
     // Make sure the first child of HEAD element is META which has charset
     // declaration in serialized contents.
     web_frame = GetMainFrame();
@@ skipping 35 matching lines @@
     for (WebNode child = head_ele.firstChild(); !child.isNull();
          child = child.nextSibling()) {
       std::string charset_info;
       if (IsMetaElement(child, charset_info) && !charset_info.empty())
         charset_declaration_count++;
     }
     // The original doc has more than META tags which have charset declaration.
     ASSERT_TRUE(charset_declaration_count > 1);
 
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
 
     // Load the serialized contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
     // Make sure only first child of HEAD element is META which has charset
     // declaration in serialized contents.
     web_frame = GetMainFrame();
@@ skipping 37 matching lines @@
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement body_ele = doc.body();
     ASSERT_TRUE(!body_ele.isNull());
     WebNode text_node = body_ele.firstChild();
     ASSERT_TRUE(text_node.isTextNode());
     ASSERT_TRUE(std::string(text_node.nodeValue().utf8()) == "&<>\"\'");
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     // 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();
@@ skipping 32 matching lines @@
     // Get value of BODY's title attribute in DOM.
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement body_ele = doc.body();
     ASSERT_TRUE(!body_ele.isNull());
     WebString value = body_ele.getAttribute("title");
     ASSERT_TRUE(std::string(value.utf8()) == "&<>\"\'");
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     // Compare the serialized contents with original contents to make sure
     // they are same.
     std::string original_str =
         WebPageSerializer::generateMarkOfTheWebDeclaration(file_url).utf8();
     original_str += original_contents;
     if (!doc.isNull()) {
@@ skipping 20 matching lines @@
     // Unescaped string for "&percnt;&nsup;&sup1;&apos;".
     static const wchar_t parsed_value[] = {
       '%', 0x2285, 0x00b9, '\'', 0
     };
     WebString value = body_element.getAttribute("title");
     WebString content = doc.contentAsTextForTesting();
     ASSERT_TRUE(base::UTF16ToWide(value) == parsed_value);
     ASSERT_TRUE(base::UTF16ToWide(content) == parsed_value);
 
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Check the serialized string.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     // Confirm that the serialized string has no non-standard HTML entities.
     ASSERT_EQ(std::string::npos, serialized_contents.find("&percnt;"));
     ASSERT_EQ(std::string::npos, serialized_contents.find("&nsup;"));
     ASSERT_EQ(std::string::npos, serialized_contents.find("&sup1;"));
     ASSERT_EQ(std::string::npos, serialized_contents.find("&apos;"));
   }
@@ skipping 32 matching lines @@
         }
       }
     }
     ASSERT_EQ(original_base_tag_count, kTotalBaseTagCountInTestFile);
     // Make sure in original document, the base URL is not equal with the
     // |path_dir_url|.
     GURL original_base_url(doc.baseURL());
     ASSERT_NE(original_base_url, path_dir_url);
 
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
 
     // Load the serialized contents.
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
 
     // Make sure all links are absolute URLs and doc there are some number of
     // BASE tags in serialized HTML data. Each of those BASE tags have same base
@@ skipping 49 matching lines @@
     WebFrame* web_frame = GetMainFrame();
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement head_element = doc.head();
     ASSERT_TRUE(!head_element.isNull());
     ASSERT_TRUE(!head_element.hasChildNodes());
     ASSERT_TRUE(head_element.childNodes().length() == 0);
 
     // Do serialization.
-    SerializeDomForURL(file_url, false);
+    SerializeDomForURL(file_url);
     // Make sure the serialized contents have META ;
     ASSERT_TRUE(HasSerializedFrame(file_url));
     const std::string& serialized_contents =
         GetSerializedContentForFrame(file_url);
 
     // Reload serialized contents and make sure there is only one META tag.
     LoadContents(serialized_contents, file_url,
                  web_frame->document().encoding());
     web_frame = GetMainFrame();
     ASSERT_TRUE(web_frame != NULL);
@@ skipping 15 matching lines @@
     // Check the body's first node is text node and its contents are
     // "hello world"
     WebElement body_element = doc.body();
     ASSERT_TRUE(!body_element.isNull());
     WebNode text_node = body_element.firstChild();
     ASSERT_TRUE(text_node.isTextNode());
     WebString text_node_contents = text_node.nodeValue();
     ASSERT_TRUE(std::string(text_node_contents.utf8()) == "hello world");
   }
 
-  void SerializeDocumentWithDownloadedIFrameOnRenderer(const GURL& file_url) {
-    // Do a recursive serialization. We pass if we don't crash.
-    SerializeDomForURL(file_url, true);
-  }
-
   void SubResourceForElementsInNonHTMLNamespaceOnRenderer(
       const GURL& file_url) {
     WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     WebNode lastNodeInBody = doc.body().lastChild();
     ASSERT_TRUE(lastNodeInBody.isElementNode());
     WebString uri = GetSubResourceLinkFromElement(
         lastNodeInBody.to<WebElement>());
     EXPECT_TRUE(uri.isNull());
@@ skipping 238 matching lines @@
   // Need to spin up the renderer and also navigate to a file url so that the
   // renderer code doesn't attempt a fork when it sees a load to file scheme
   // from non-file scheme.
   NavigateToURL(shell(), GetTestUrl(".", "simple_page.html"));
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(&DomSerializerTests::SerializeHTMLDOMWithEmptyHeadOnRenderer,
                    base::Unretained(this)));
 }
 
-// Test that we don't crash when the page contains an iframe that
-// was handled as a download (http://crbug.com/42212).
-IN_PROC_BROWSER_TEST_F(DomSerializerTests,
-                       SerializeDocumentWithDownloadedIFrame) {
-  base::FilePath page_file_path = GetTestFilePath(
-      "dom_serializer", "iframe-src-is-exe.htm");
-  GURL file_url = net::FilePathToFileURL(page_file_path);
-  ASSERT_TRUE(file_url.SchemeIsFile());
-  // Load the test file.
-  NavigateToURL(shell(), file_url);
-
-  PostTaskToInProcessRendererAndWait(
-        base::Bind(
-            &DomSerializerTests::
-                SerializeDocumentWithDownloadedIFrameOnRenderer,
-            base::Unretained(this), file_url));
-}
-
 IN_PROC_BROWSER_TEST_F(DomSerializerTests,
                        SubResourceForElementsInNonHTMLNamespace) {
   base::FilePath page_file_path = GetTestFilePath(
       "dom_serializer", "non_html_namespace.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   NavigateToURL(shell(), file_url);
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(
             &DomSerializerTests::
                 SubResourceForElementsInNonHTMLNamespaceOnRenderer,
             base::Unretained(this), file_url));
 }
 
 }  // namespace content