ABANDONED: OOPIFs: Moving stitching of local paths from renderer to browser process.

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 39 matching lines @@
 using blink::WebPageSerializer;
 using blink::WebPageSerializerClient;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebView;
 using blink::WebVector;
 
 namespace content {
 
 // Iterate recursively over sub-frames to find one with with a given url.
-WebFrame* FindSubFrameByURL(WebView* web_view, const GURL& url) {
+WebFrame* FindSubframeByURL(WebView* web_view, const GURL& url) {
   if (!web_view->mainFrame())
     return NULL;
 
   std::vector<WebFrame*> stack;
   stack.push_back(web_view->mainFrame());
 
   while (!stack.empty()) {
     WebFrame* current_frame = stack.back();
     stack.pop_back();
     if (GURL(current_frame->document().url()) == url)
@@ skipping 81 matching lines @@
   }
 
  private:
   base::Closure quit_closure_;
 };
 
 class DomSerializerTests : public ContentBrowserTest,
                            public WebPageSerializerClient {
  public:
   DomSerializerTests()
-    : serialized_(false),
-      local_directory_name_(FILE_PATH_LITERAL("./dummy_files/")) {}
+      : got_end_of_frame_notification_(false),
+        local_directory_name_(FILE_PATH_LITERAL("./dummy_files/")) {}
 
   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 WebURL& frame_web_url,
-                                const WebCString& data,
-                                PageSerializationStatus status) override {
-    GURL frame_url(frame_web_url);
-    // If the all frames are finished saving, check all finish status
-    if (status == WebPageSerializerClient::AllFramesAreFinished) {
-      SerializationFinishStatusMap::iterator it =
-          serialization_finish_status_.begin();
-      for (; it != serialization_finish_status_.end(); ++it)
-        ASSERT_TRUE(it->second);
-      serialized_ = true;
-      return;
-    }
-
-    // Check finish status of current frame.
-    SerializationFinishStatusMap::iterator it =
-        serialization_finish_status_.find(frame_url.spec());
-    // New frame, set initial status as false.
-    if (it == serialization_finish_status_.end())
-      serialization_finish_status_[frame_url.spec()] = false;
-
-    it = serialization_finish_status_.find(frame_url.spec());
-    ASSERT_TRUE(it != serialization_finish_status_.end());
-    // In process frame, finish status should be false.
-    ASSERT_FALSE(it->second);
-
-    // Add data to corresponding frame's content.
-    serialized_frame_map_[frame_url.spec()] += data.data();
-
-    // Current frame is completed saving, change the finish status.
-    if (status == WebPageSerializerClient::CurrentFrameIsFinished)
-      it->second = true;
+  void writeHtmlFragment(const WebCString& data) override {
+    serialization_output_ += data.data();
   }
 
-  bool HasSerializedFrame(const GURL& frame_url) {
-    return serialized_frame_map_.find(frame_url.spec()) !=
-           serialized_frame_map_.end();
+  void writeLocalPathForSubframe(const WebFrame& subframe) override {
+    // Tests in content/renderer/dom_serializer_browsertest.cc do not verify
+    // local paths in the serializer html (they are verified by
+    // chrome/browser/download/save_page_browsertest.cc).  Therefore the body of
+    // writeLocalPathForSubframe can be empty below.
   }
 
-  const std::string& GetSerializedContentForFrame(
-      const GURL& frame_url) {
-    return serialized_frame_map_[frame_url.spec()];
+  void writeLocalPathForSavableResource(
+      const WebURL& savableResourceURL) override {
+    // Tests in content/renderer/dom_serializer_browsertest.cc do not verify
+    // local paths in the serializer html (they are verified by
+    // chrome/browser/download/save_page_browsertest.cc).  Therefore the body of
+    // writeLocalPathForSavableResource can be empty below.
   }
 
+  void endOfFrame() override { got_end_of_frame_notification_ = true; }
+
+  const std::string& GetSerializedContent() { return serialization_output_; }
+
   RenderView* GetRenderView() {
     return RenderView::FromRoutingID(render_view_routing_id_);
   }
 
   WebView* GetWebView() {
     return GetRenderView()->GetWebView();
   }
 
   WebFrame* GetMainFrame() {
     return GetWebView()->mainFrame();
@@ skipping 22 matching lines @@
 
       web_frame->loadData(data, "text/html", encoding_info, base_url);
     }
 
     runner->Run();
   }
 
   // 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);
+    WebFrame* web_frame = FindSubframeByURL(GetWebView(), frame_url);
     ASSERT_TRUE(web_frame != NULL);
     WebVector<WebURL> links;
     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(),
-       static_cast<WebPageSerializerClient*>(this),
-       links,
-       local_paths,
-       local_directory_name_.AsUTF16Unsafe());
+    bool result = WebPageSerializer::serialize(
+        web_frame->toWebLocalFrame(),
+        static_cast<WebPageSerializerClient*>(this));
     ASSERT_TRUE(result);
-    ASSERT_TRUE(serialized_);
+    ASSERT_TRUE(got_end_of_frame_notification_);
   }
 
   void SerializeHTMLDOMWithDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents have document type.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
+    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);
     // Load the serialized contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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);
+    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);
     // Load the serialized contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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);
     // Compare the serialized contents with original contents.
-    ASSERT_TRUE(HasSerializedFrame(xml_file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(xml_file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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);
     // Make sure the serialized contents have MOTW ;
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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);
+    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);
 
     // Load the serialized contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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();
     ASSERT_TRUE(web_frame != NULL);
     doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     head_element = doc.head();
     ASSERT_TRUE(!head_element.isNull());
@@ skipping 12 matching lines @@
       std::string charset_info;
       if (IsMetaElement(child, charset_info))
         ASSERT_TRUE(charset_info.empty());
     }
   }
 
   void SerializeHTMLDOMWithMultipleMetaCharsetInOriginalDocOnRenderer(
       const GURL& file_url) {
     // Make sure there are multiple META charset declarations in original
     // document.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
+    WebFrame* web_frame = FindSubframeByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement head_ele = doc.head();
     ASSERT_TRUE(!head_ele.isNull());
     // Go through all children of HEAD element.
     int charset_declaration_count = 0;
     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);
 
     // Load the serialized contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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();
     ASSERT_TRUE(web_frame != NULL);
     doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     head_ele = doc.head();
     ASSERT_TRUE(!head_ele.isNull());
@@ skipping 22 matching lines @@
     // actions. The test content is in constant:original_contents.
     GURL file_url = net::FilePathToFileURL(page_file_path);
     ASSERT_TRUE(file_url.SchemeIsFile());
     // Test contents.
     static const char* const original_contents =
         "<html><body>&amp;&lt;&gt;\"\'</body></html>";
     // Load the test contents.
     LoadContents(original_contents, file_url, WebString());
 
     // Get BODY's text content in DOM.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
+    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);
     // Compare the serialized contents with original contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     // 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();
     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
@@ skipping 19 matching lines @@
     // Get file URL. The URL is dummy URL to identify the following loading
     // actions. The test content is in constant:original_contents.
     GURL file_url = net::FilePathToFileURL(page_file_path);
     ASSERT_TRUE(file_url.SchemeIsFile());
     // Test contents.
     static const char* const original_contents =
         "<html><body title=\"&amp;&lt;&gt;&quot;&#39;\"></body></html>";
     // Load the test contents.
     LoadContents(original_contents, file_url, WebString());
     // Get value of BODY's title attribute in DOM.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
+    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);
     // Compare the serialized contents with original contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     // 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()) {
       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();
       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(GetWebView(), file_url);
+    WebFrame* web_frame = FindSubframeByURL(GetWebView(), file_url);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     WebElement body_element = doc.body();
     // 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);
     // Check the serialized string.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     // 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;"));
   }
 
   void SerializeHTMLDOMWithBaseTagOnRenderer(const GURL& file_url,
                                              const GURL& path_dir_url) {
     // There are total 2 available base tags in this test file.
     const int kTotalBaseTagCountInTestFile = 2;
 
     // Since for this test, we assume there is no savable sub-resource links for
     // this test file, also all links are relative URLs in this test file, so we
     // need to check those relative URLs and make sure document has BASE tag.
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), file_url);
+    WebFrame* web_frame = FindSubframeByURL(GetWebView(), file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     // Go through all descent nodes.
     WebElementCollection all = doc.all();
     int original_base_tag_count = 0;
     for (WebElement element = all.firstItem(); !element.isNull();
          element = all.nextItem()) {
       if (element.hasHTMLTagName("base")) {
         original_base_tag_count++;
@@ skipping 15 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);
 
     // Load the serialized contents.
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
     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
     // URL which is as same as URL of current test file.
     web_frame = GetMainFrame();
     ASSERT_TRUE(web_frame != NULL);
     doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
@@ skipping 46 matching lines @@
     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);
     // Make sure the serialized contents have META ;
-    ASSERT_TRUE(HasSerializedFrame(file_url));
-    const std::string& serialized_contents =
-        GetSerializedContentForFrame(file_url);
+    const std::string& serialized_contents = GetSerializedContent();
 
     // 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);
     doc = web_frame->document();
     ASSERT_TRUE(doc.isHTMLDocument());
     head_element = doc.head();
     ASSERT_TRUE(!head_element.isNull());
@@ skipping 13 matching lines @@
     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 SubResourceForElementsInNonHTMLNamespaceOnRenderer(
       const GURL& file_url) {
-    WebFrame* web_frame = FindSubFrameByURL(GetWebView(), 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());
   }
 
  private:
   int32 render_view_routing_id_;
-  // Map frame_url to corresponding serialized_content.
-  typedef base::hash_map<std::string, std::string> SerializedFrameContentMap;
-  SerializedFrameContentMap serialized_frame_map_;
+  std::string serialization_output_;
   // Map frame_url to corresponding status of serialization finish.
   typedef base::hash_map<std::string, bool> SerializationFinishStatusMap;
   SerializationFinishStatusMap serialization_finish_status_;
   // Flag indicates whether the process of serializing DOM is finished or not.
-  bool serialized_;
+  bool got_end_of_frame_notification_;
   // The local_directory_name_ is dummy relative path of directory which
   // contain all saved auxiliary files included all sub frames and resources.
   const base::FilePath local_directory_name_;
 };
 
 // If original contents have document type, the serialized contents also have
 // document type.
 // Disabled by ellyjones@ on 2015-05-18, see https://crbug.com/488495.
 #if defined(OS_MACOSX)
 #define MAYBE_SerializeHTMLDOMWithDocType DISABLED_SerializeHTMLDOMWithDocType
@@ skipping 231 matching lines @@
   NavigateToURL(shell(), file_url);
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(
             &DomSerializerTests::
                 SubResourceForElementsInNonHTMLNamespaceOnRenderer,
             base::Unretained(this), file_url));
 }
 
 }  // namespace content