Remove hidden elements from MHTML

chrome/browser/download/save_page_browsertest.cc

 // Copyright (c) 2012 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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1007 matching lines @@
 
 // Test suite that verifies that the frame tree "looks" the same before
 // and after a save-page-as.
 class SavePageOriginalVsSavedComparisonTest
     : public SavePageSitePerProcessBrowserTest,
       public ::testing::WithParamInterface<content::SavePageType> {
  protected:
   void TestOriginalVsSavedPage(
       content::SavePageType save_page_type,
       const GURL& url,
-      int expected_number_of_frames,
+      int expected_number_of_frames_in_original_page,
+      int expected_number_of_frames_in_mhtml_page,
       const std::vector<std::string>& expected_substrings) {
     // Navigate to the test page and verify if test expectations
     // are met (this is mostly a sanity check - a failure to meet
     // expectations would probably mean that there is a test bug
     // (i.e. that we got called with wrong expected_foo argument).
     ui_test_utils::NavigateToURL(browser(), url);
     DLOG(INFO) << "Verifying test expectations for original page... : "
                << GetCurrentTab(browser())->GetLastCommittedURL();
-    AssertExpectationsAboutCurrentTab(expected_number_of_frames,
-                                      expected_substrings);
+    AssertExpectationsAboutCurrentTab(
+        expected_number_of_frames_in_original_page, expected_substrings);
 
     // Save the page.
     base::FilePath full_file_name, dir;
     SaveCurrentTab(url, save_page_type, "save_result", -1, &dir,
                    &full_file_name);
     ASSERT_FALSE(HasFailure());
 
     // Stop the test server (to make sure the locally saved page
     // is self-contained / won't try to open original resources).
     ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
 
     // Open the saved page and verify if test expectations are
     // met (i.e. if the same expectations are met for "after"
     // [saved version of the page] as for the "before"
     // [the original version of the page].
     ui_test_utils::NavigateToURL(browser(),
                                  GURL(net::FilePathToFileURL(full_file_name)));
     DLOG(INFO) << "Verifying test expectations for saved page... : "
                << GetCurrentTab(browser())->GetLastCommittedURL();
-    AssertExpectationsAboutCurrentTab(expected_number_of_frames,
+    // Hidden elements, i.e., hidden frames, will be removed only from MHTML
+    // page. They're still kept in other types of serialization, like saving
+    // as a complete html page.
+    int expected_number_of_frames_in_saved_page =
+        (save_page_type == content::SAVE_PAGE_TYPE_AS_MHTML) ?
+        expected_number_of_frames_in_mhtml_page :
+        expected_number_of_frames_in_original_page;
+    AssertExpectationsAboutCurrentTab(expected_number_of_frames_in_saved_page,
                                       expected_substrings);
   }
 
   // Helper method to deduplicate some code across 2 tests.
   void RunObjectElementsTest(GURL url) {
     content::SavePageType save_page_type = GetParam();
 
     // 7 comes from:
     // - main frame (frames-objects.htm)
     // - object with frame-nested.htm + 2 subframes (frames-nested2.htm + b.htm)
@@ skipping 12 matching lines @@
         "text-object.txt: ae52dd09-9746-4b7e-86a6-6ada5e2680c2",
     };
     std::vector<std::string> expected_substrings(std::begin(arr),
                                                  std::end(arr));
 
     // TODO(lukasza): crbug.com/553478: Enable <object> testing of MHTML.
     if (save_page_type == content::SAVE_PAGE_TYPE_AS_MHTML)
       return;
 
     TestOriginalVsSavedPage(save_page_type, url, expected_number_of_frames,
-                            expected_substrings);
+                            expected_number_of_frames, expected_substrings);
   }
 
  private:
   void AssertExpectationsAboutCurrentTab(
       int expected_number_of_frames,
       const std::vector<std::string>& expected_substrings) {
     int actual_number_of_frames = 0;
     GetCurrentTab(browser())->ForEachFrame(base::Bind(
         &IncrementInteger, base::Unretained(&actual_number_of_frames)));
     EXPECT_EQ(expected_number_of_frames, actual_number_of_frames);
@@ skipping 46 matching lines @@
   std::string arr[] = {
       "frames-xsite.htm: 896fd88d-a77a-4f46-afd8-24db7d5af9c2",
       "a.htm: 1b8aae2b-e164-462f-bd5b-98aa366205f2",
       "b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-xsite.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 3, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 3, 3, expected_substrings);
 }
 
 // Test compares original-vs-saved for a page with <object> elements.
 // (see crbug.com/553478).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest,
                        ObjectElementsViaHttp) {
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-objects.htm"));
 
   RunObjectElementsTest(url);
@@ skipping 21 matching lines @@
       "main: acb0609d-eb10-4c26-83e2-ad8afb7b0ff3",
       "sub1: b124df3a-d39f-47a1-ae04-5bb5d0bf549e",
       "sub2: 07014068-604d-45ae-884f-a068cfe7bc0a",
       "sub3: 06cc8fcc-c692-4a1a-a10f-1645b746e8f4",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL("a.com",
                                           "/save_page/frames-about-blank.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 4, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 4, 4, expected_substrings);
 }
 
 // Test compares original-vs-saved for a page with nested frames.
 // Two levels of nesting are especially good for verifying correct
 // link rewriting for subframes-vs-main-frame (see crbug.com/554666).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, NestedFrames) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "frames-nested.htm: 4388232f-8d45-4d2e-9807-721b381be153",
       "frames-nested2.htm: 6d23dc47-f283-4977-96ec-66bcf72301a4",
       "b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-nested.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 3, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 3, 3, expected_substrings);
 }
 
 // Test for crbug.com/106364 and crbug.com/538188.
 // Test frames have the same uri ...
 //   subframe1 and subframe2 - both have src=b.htm
 //   subframe3 and subframe4 - about:blank (no src, only srcdoc attribute).
 // ... but different content (generated by main frame's javascript).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, RuntimeChanges) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "frames-runtime-changes.htm: 4388232f-8d45-4d2e-9807-721b381be153",
       "subframe1: 21595339-61fc-4854-b6df-0668328ea263",
       "subframe2: adf55719-15e7-45be-9eda-d12fe782a1bd",
       "subframe3: 50e294bf-3a5b-499d-8772-651ead26952f",
       "subframe4: e0ea9289-7467-4d32-ba5c-c604e8d84cb7",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL(
       "a.com", "/save_page/frames-runtime-changes.htm?do_runtime_changes=1"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 5, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 5, 5, expected_substrings);
 }
 
 // Test for saving frames with various encodings:
 // - iso-8859-2: encoding declared via <meta> element
 // - utf16-le-bom.htm, utf16-be-bom.htm: encoding detected via BOM
 // - utf16-le-nobom.htm, utf16-le-nobom.htm, utf32.htm - encoding declared via
 //                                                       mocked http headers
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, Encoding) {
   content::SavePageType save_page_type = GetParam();
 
@@ skipping 19 matching lines @@
 
   // TODO(lukasza): crbug.com/541699: MHTML needs to handle multi-byte encodings
   // by either:
   // 1. Continuing to preserve the original encoding, but starting to round-trip
   //    the encoding declaration (in Content-Type MIME/MHTML header?)
   // 2. Saving html docs in UTF8.
   // 3. Saving the BOM (not sure if this will help for all cases though).
   if (save_page_type == content::SAVE_PAGE_TYPE_AS_MHTML)
     return;
 
-  TestOriginalVsSavedPage(save_page_type, url, 7, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 7, 7, expected_substrings);
 }
 
 // Test for saving style element and attribute (see also crbug.com/568293).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, Style) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "style.htm: af84c3ca-0fc6-4b0d-bf7a-5ac18a4dab62",
-      "frameE: c9539ccd-47b0-47cf-a03b-734614865872",
+      "frameF: c9539ccd-47b0-47cf-a03b-734614865872",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL("a.com", "/save_page/style.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 6, expected_substrings);
+  // The original page has 7 iframes. 2 of them are both hidden and affecting
+  // no layout. So these two are excluded from the saved page.
+  TestOriginalVsSavedPage(save_page_type, url, 7, 5, expected_substrings);
 }
 
 // Test for saving a page with broken subresources:
 // - Broken, undecodable image (see also https://crbug.com/586680)
 // - Broken link, to unresolvable host (see also https://crbug.com/594219)
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, BrokenImage) {
   // Clear resolver rules to make sure that *.no.such.host used in the test html
   // doesn't resolve to 127.0.0.1
   host_resolver()->ClearRules();
 
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "broken-image.htm: 1e846775-b3ed-4d9c-a124-029554a1eb9d",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL("127.0.0.1",
                                           "/save_page/broken-image.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 1, expected_substrings);
+  TestOriginalVsSavedPage(save_page_type, url, 1, 1, expected_substrings);
 }
 
 INSTANTIATE_TEST_CASE_P(
     SaveType,
     SavePageOriginalVsSavedComparisonTest,
     ::testing::Values(content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                       content::SAVE_PAGE_TYPE_AS_MHTML));
 
 }  // namespace