Allow Offline MHTML save operations to succeed even with missing frames.

content/browser/download/mhtml_generation_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 <stdint.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_restrictions.h"
+#include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/web_contents.h"
 #include "content/public/common/mhtml_generation_params.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "net/base/filename_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 68 matching lines @@
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(embedded_test_server()->Start());
     ContentBrowserTest::SetUp();
   }
 
   void GenerateMHTML(const base::FilePath& path, const GURL& url) {
     GenerateMHTML(MHTMLGenerationParams(path), url);
   }
 
   void GenerateMHTML(const MHTMLGenerationParams& params, const GURL& url) {
-    NavigateToURL(shell(), url);
+    ASSERT_TRUE(NavigateToURL(shell(), url));
     GenerateMHTMLForCurrentPage(params);
   }
 
   void GenerateMHTMLForCurrentPage(const MHTMLGenerationParams& params) {
     base::RunLoop run_loop;
     histogram_tester_.reset(new base::HistogramTester());
 
     shell()->web_contents()->GenerateMHTML(
         params, base::Bind(&MHTMLGenerationTest::MHTMLGenerated,
                            base::Unretained(this),
@@ skipping 16 matching lines @@
       const GURL& url,
       const MHTMLGenerationParams params,
       int expected_number_of_frames,
       const std::vector<std::string>& expected_substrings,
       const std::vector<std::string>& forbidden_substrings_in_saved_page,
       bool skip_verification_of_original_page = false) {
     // 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).
-    NavigateToURL(shell(), url);
+    ASSERT_TRUE(NavigateToURL(shell(), url));
     if (!skip_verification_of_original_page) {
       AssertExpectationsAboutCurrentTab(expected_number_of_frames,
                                         expected_substrings,
                                         std::vector<std::string>());
     }
 
     GenerateMHTML(params, url);
     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].
-    NavigateToURL(shell(), net::FilePathToFileURL(params.file_path));
+    ASSERT_TRUE(
+        NavigateToURL(shell(), net::FilePathToFileURL(params.file_path)));
     AssertExpectationsAboutCurrentTab(expected_number_of_frames,
                                       expected_substrings,
                                       forbidden_substrings_in_saved_page);
   }
 
   void AssertExpectationsAboutCurrentTab(
       int expected_number_of_frames,
       const std::vector<std::string>& expected_substrings,
       const std::vector<std::string>& forbidden_substrings) {
     int actual_number_of_frames =
@@ skipping 39 matching lines @@
 
 // Tests that generating a MHTML does create contents.
 // Note that the actual content of the file is not tested, the purpose of this
 // test is to ensure we were successful in creating the MHTML data from the
 // renderer.
 IN_PROC_BROWSER_TEST_F(MHTMLGenerationTest, GenerateMHTML) {
   base::FilePath path(temp_dir_.GetPath());
   path = path.Append(FILE_PATH_LITERAL("test.mht"));
 
   GenerateMHTML(path, embedded_test_server()->GetURL("/simple_page.html"));
+
+  // Checks that no other test failure was detected so far.
   ASSERT_FALSE(HasFailure());
 
   // Make sure the actual generated file has some contents.
   EXPECT_GT(file_size(), 0);  // Verify the size reported by the callback.
   EXPECT_GT(ReadFileSizeFromDisk(path), 100);  // Verify the actual file size.
 
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io_for_content_verification;
     std::string mhtml;
     ASSERT_TRUE(base::ReadFileToString(path, &mhtml));
     EXPECT_THAT(mhtml,
                 HasSubstr("Content-Transfer-Encoding: quoted-printable"));
   }
 
   // Checks that the final status reported to UMA is correct.
   histogram_tester()->ExpectUniqueSample(
       "PageSerialization.MhtmlGeneration.FinalSaveStatus",
       static_cast<int>(MhtmlSaveStatus::SUCCESS), 1);
 }
 
+// Removes all children of the root tree node once the first MHTML serialization
+// response (regarding the main frame) is received from the renderer but before
+// that message is actually handled by the browser UI thread.
+class ChildFrameRemoverFilter : public BrowserMessageFilter {
+ public:
+  ChildFrameRemoverFilter(WebContentsImpl* web_contents)
+      : BrowserMessageFilter(FrameMsgStart), web_contents_(web_contents) {
+    DCHECK(web_contents_);
+  }
+
+ protected:
+  ~ChildFrameRemoverFilter() override {}
+
+ private:
+  bool OnMessageReceived(const IPC::Message& message) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    if (message.type() == FrameHostMsg_SerializeAsMHTMLResponse::ID) {
+      if (!already_received_response_) {
+        already_received_response_ = true;
+        BrowserThread::PostTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&ChildFrameRemoverFilter::RemoveAllChildFrames,
+                       base::Unretained(this)));
+      } else {
+        ADD_FAILURE()
+            << "Should not receive another MHTML serialization response";
+      }
+    }
+    return false;
+  }
+
+  void RemoveAllChildFrames() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    int tree_node_count = 1;
+    for (auto tree_node : web_contents_->GetFrameTree()->Nodes())
+      tree_node_count += tree_node->child_count();
+    // Note: at least 2 children nodes are needed to test all code paths.
+    ASSERT_GE(tree_node_count, 3);
+    FrameTreeNode* root = web_contents_->GetFrameTree()->root();
+    while (root->child_count())
+      root->RemoveChild(root->child_at(0));
+    ASSERT_EQ(0u, root->child_count());
+  }
+
+  WebContentsImpl* web_contents_;
+  bool already_received_response_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(ChildFrameRemoverFilter);
+};
+
+// Tests that if child frames are removed while saving a MHTML page the
+// operation fails by default.
+IN_PROC_BROWSER_TEST_F(MHTMLGenerationTest, FailDueToMissingIframe) {
+  ASSERT_TRUE(NavigateToURL(
+      shell(), embedded_test_server()->GetURL("/site_per_process_main.html")));
+
+  scoped_refptr<BrowserMessageFilter> filter = new ChildFrameRemoverFilter(
+      static_cast<WebContentsImpl*>(shell()->web_contents()));
+  shell()->web_contents()->GetRenderProcessHost()->AddFilter(filter.get());
+
+  base::FilePath path(temp_dir_.GetPath());
+  path = path.Append(FILE_PATH_LITERAL("test.mht"));
+
+  MHTMLGenerationParams params(path);
+
+  // Verifies the default is to not ignore missing iframes.
+  ASSERT_FALSE(params.ignore_missing_frames);
+
+  GenerateMHTMLForCurrentPage(params);
+
+  // Checks that no other test failure was detected so far.
+  ASSERT_FALSE(HasFailure());
+
+  // Verify the size reported by the callback is negative (an error happened).
+  EXPECT_LT(file_size(), 0);
+
+  // Checks that the final status reported to UMA is correct.
+  histogram_tester()->ExpectUniqueSample(
+      "PageSerialization.MhtmlGeneration.FinalSaveStatus",
+      static_cast<int>(MhtmlSaveStatus::FRAME_NO_LONGER_EXISTS), 1);
+}
+
+// Tests that a MHTML save operation does not fail when frames are removed if
+// the caller configures it to ignore missing frames.
+IN_PROC_BROWSER_TEST_F(MHTMLGenerationTest, SucceedIgnoringMissingIframe) {
+  ASSERT_TRUE(NavigateToURL(
+      shell(), embedded_test_server()->GetURL("/site_per_process_main.html")));
+
+  scoped_refptr<BrowserMessageFilter> filter = new ChildFrameRemoverFilter(
+      static_cast<WebContentsImpl*>(shell()->web_contents()));
+  shell()->web_contents()->GetRenderProcessHost()->AddFilter(filter.get());
+
+  base::FilePath path(temp_dir_.GetPath());
+  path = path.Append(FILE_PATH_LITERAL("test.mht"));
+
+  MHTMLGenerationParams params(path);
+
+  // Enables the ignoring of missing iframes.
+  params.ignore_missing_frames = true;
+
+  GenerateMHTMLForCurrentPage(params);
+
+  // Checks that no other test failure was detected so far.
+  ASSERT_FALSE(HasFailure());
+
+  // Verify the size reported by the callback is positive.
+  EXPECT_GT(file_size(), 0);
+
+  // Checks that the final status reported to UMA is correct.
+  histogram_tester()->ExpectUniqueSample(
+      "PageSerialization.MhtmlGeneration.FinalSaveStatus",
+      static_cast<int>(MhtmlSaveStatus::SUCCESS), 1);
+}
+
 class GenerateMHTMLAndExitRendererMessageFilter : public BrowserMessageFilter {
  public:
   GenerateMHTMLAndExitRendererMessageFilter(
       RenderProcessHostImpl* render_process_host)
       : BrowserMessageFilter(FrameMsgStart),
         render_process_host_(render_process_host) {}
 
  protected:
   ~GenerateMHTMLAndExitRendererMessageFilter() override {}
 
  private:
   bool OnMessageReceived(const IPC::Message& message) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (message.type() == FrameHostMsg_SerializeAsMHTMLResponse::ID) {
       // After |return false| below, this IPC message will be handled by the
       // product code as illustrated below.  (1), (2), (3) depict points in time
       // when product code runs on UI and FILE threads.  (X), (Y), (Z) depict
       // when we want test-injected tasks to run - for the repro, (Z) has to
       // happen between (1) and (3).  (Y?) and (Z?) depict when test tasks can
       // theoretically happen and ruin the repro.
       //
       //     IO thread       UI thread           FILE thread
       //     ---------       ---------           -----------
@@ skipping 43 matching lines @@
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE, base::Bind(
               &GenerateMHTMLAndExitRendererMessageFilter::TaskX,
               base::Unretained(this)));
     }
 
     return false;
   };
 
   void TaskX() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE, base::Bind(
             &GenerateMHTMLAndExitRendererMessageFilter::TaskY,
             base::Unretained(this)));
   }
 
   void TaskY() {
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(
             &GenerateMHTMLAndExitRendererMessageFilter::TaskZ,
             base::Unretained(this)));
   }
 
   void TaskZ() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     render_process_host_->FastShutdownIfPossible();
   }
 
   RenderProcessHostImpl* render_process_host_;
 
   DISALLOW_COPY_AND_ASSIGN(GenerateMHTMLAndExitRendererMessageFilter);
 };
 
 // Regression test for the crash/race from https://crbug.com/612098.
 IN_PROC_BROWSER_TEST_F(MHTMLGenerationTest, GenerateMHTMLAndExitRenderer) {
-  NavigateToURL(shell(), embedded_test_server()->GetURL("/simple_page.html"));
+  ASSERT_TRUE(NavigateToURL(
+      shell(), embedded_test_server()->GetURL("/simple_page.html")));
 
   RenderProcessHostImpl* render_process_host =
       static_cast<RenderProcessHostImpl*>(
           shell()->web_contents()->GetRenderProcessHost());
   scoped_refptr<BrowserMessageFilter> filter =
       new GenerateMHTMLAndExitRendererMessageFilter(render_process_host);
   render_process_host->AddFilter(filter.get());
 
   base::FilePath path(temp_dir_.GetPath());
   path = path.Append(FILE_PATH_LITERAL("test.mht"));
@@ skipping 289 matching lines @@
 
   // Make sure that URLs of both frames are present
   // (note that these are single-line regexes).
   EXPECT_THAT(
       mhtml,
       ContainsRegex("Content-Location:.*/frame_tree/page_with_one_frame.html"));
   EXPECT_THAT(mhtml, ContainsRegex("Content-Location:.*/title1.html"));
 }
 
 }  // namespace content