Assertion removed in print_preview_pdf_generated.cc.

chrome/browser/printing/print_preview_pdf_generated_browsertest.cc

 // Copyright 2014 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 <algorithm>
 #include <fstream>
 #include <iostream>
 #include <iterator>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/scoped_native_library.h"
@@ skipping 76 matching lines @@
   bool background_colors_and_images;
   MarginType margins;
   bool source_is_pdf;
 };
 
 // Observes the print preview webpage. Once it observes the PreviewPageCount
 // message, will send a sequence of commands to the print preview dialog and
 // change the settings of the preview dialog.
 class PrintPreviewObserver : public WebContentsObserver {
  public:
-  PrintPreviewObserver(Browser* browser, WebContents* dialog)
+  PrintPreviewObserver(Browser* browser,
+                       WebContents* dialog,
+                       const base::FilePath& pdf_file_save_path)
       : WebContentsObserver(dialog),
         browser_(browser),
         state_(kWaitingToSendSaveAsPdf),
-        failed_setting_("None") {}
+        failed_setting_("None"),
+        pdf_file_save_path_(pdf_file_save_path) {}
 
   virtual ~PrintPreviewObserver() {}
 
   // Sets closure for the observer so that it can end the loop.
   void set_quit_closure(const base::Closure &closure) {
     quit_closure_ = closure;
   }
 
   // Actually stops the message loop so that the test can proceed.
   void EndLoop() {
@@ skipping 52 matching lines @@
     } else if (state_ == kWaitingToSendBackgroundColorsAndImages) {
       script_argument.SetBoolean("backgroundColorsAndImages",
                                  settings_->background_colors_and_images);
       state_ = kWaitingToSendMargins;
       failed_setting_ = "Background Colors and Images";
     } else if (state_ == kWaitingToSendMargins) {
       script_argument.SetInteger("margins", settings_->margins);
       state_ = kWaitingForFinalMessage;
       failed_setting_ = "Margins";
     } else if (state_ == kWaitingForFinalMessage) {
-      EndLoop();
+      // Called by PrintPreviewMessageHandler when the PDF is saved. This ends
+      // the message loop for |this|.
+      base::Closure end_loop_callback =
+          base::Bind(&PrintPreviewObserver::EndLoop, base::Unretained(this));
+      GetUI()->SetPdfSavedCallbackForTesting(end_loop_callback);
+      GetUI()->SetSelectedFileForTesting(pdf_file_save_path_);
       return;
     }
 
     ASSERT_FALSE(script_argument.empty());
     GetUI()->web_ui()->CallJavascriptFunction(
         "onManipulateSettingsForTest", script_argument);
   }
 
   // Saves the print preview settings to be sent to the print preview dialog.
   void SetPrintPreviewSettings(const PrintPreviewSettings& settings) {
@@ skipping 67 matching lines @@
     ui->web_ui()->AddMessageHandler(new UIDoneLoadingMessageHandler(this));
     ui->web_ui()->CallJavascriptFunction("onEnableManipulateSettingsForTest");
   }
 
   virtual void DidCloneToNewWebContents(
       WebContents* old_web_contents,
       WebContents* new_web_contents) OVERRIDE {
     Observe(new_web_contents);
   }
 
-  virtual void WebContentsDestroyed() OVERRIDE {
-    EndLoop();
-  }
-
   Browser* browser_;
   base::Closure quit_closure_;
   scoped_ptr<PrintPreviewSettings> settings_;
 
   // State of the observer. The state indicates what message to send
   // next. The state advances whenever the message handler calls
   // ManipulatePreviewSettings() on the observer.
   State state_;
   std::string failed_setting_;
+  base::FilePath pdf_file_save_path_;
 
   DISALLOW_COPY_AND_ASSIGN(PrintPreviewObserver);
 };
 
 class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
  public:
   PrintPreviewPdfGeneratedBrowserTest() {}
   virtual ~PrintPreviewPdfGeneratedBrowserTest() {}
 
   // Navigates to the given web page, then initiates print preview and waits
-  // for all the settings to be set.
-  void NavigateAndPreview(const base::FilePath::StringType& file_name,
+  // for all the settings to be set, then the webpage is printed to a PDF.

[Lei Zhang, 2014/07/22 03:04:39]

... then save the preview to PDF.

[ivandavid, 2014/07/22 19:02:00]

Done.

+  void NavigateAndPrint(const base::FilePath::StringType& file_name,
                           const PrintPreviewSettings& settings) {
     print_preview_observer_->SetPrintPreviewSettings(settings);
     base::FilePath path(file_name);
     GURL gurl = net::FilePathToFileURL(path);
 
     ui_test_utils::NavigateToURL(browser(), gurl);
 
     base::RunLoop loop;
     print_preview_observer_->set_quit_closure(loop.QuitClosure());
     chrome::Print(browser());
     loop.Run();
   }
 
-  // Prints the web page to a PDF. NavigateAndPreview must be called first.
-  void Print() {
-    ASSERT_FALSE(pdf_file_save_path_.empty());
-
-    base::RunLoop loop;
-    print_preview_observer_->set_quit_closure(loop.QuitClosure());
-    print_preview_observer_->GetUI()->SetSelectedFileForTesting(
-        pdf_file_save_path_);
-    loop.Run();
-
-    // Checks to see if the file exists and is readable. If the file doesn't
-    // exist, the test will fail. If it exists, but isn't readable, the test
-    // will keep polling until the file becomes readable. This is due to a
-    // problem on Windows where the file exists, but isn't readable, causing
-    // other ASSERT statements in this test to fail.
-    // TODO(ivandavid): Come up with a better way to do this.
-    ASSERT_TRUE(base::PathExists(pdf_file_save_path_));
-    while (true) {
-      base::File pdf_file(
-          pdf_file_save_path_, base::File::FLAG_OPEN | base::File::FLAG_READ);
-      if (pdf_file.IsValid())
-        break;
-    }
-  }
-
   // Initializes function pointers from the PDF library. Called once when the
   // test starts. The library is closed when the browser test ends.
   void InitPdfFunctions() {
     base::FilePath pdf_module_path;
 
     ASSERT_TRUE(PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path));
     ASSERT_TRUE(base::PathExists(pdf_module_path));
     pdf_lib_.Reset(base::LoadNativeLibrary(pdf_module_path, NULL));
 
     ASSERT_TRUE(pdf_lib_.is_valid());
@@ skipping 140 matching lines @@
   }
 
   // Duplicates the tab that was created when the browser opened. This is done
   // so that the observer can listen to the duplicated tab as soon as possible
   // and start listening for messages related to print preview.
   void DuplicateTab() {
     WebContents* tab =
         browser()->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(tab);
 
-    print_preview_observer_.reset(new PrintPreviewObserver(browser(), tab));
+    print_preview_observer_.reset(
+        new PrintPreviewObserver(browser(), tab, pdf_file_save_path_));
     chrome::DuplicateTab(browser());
 
     WebContents* initiator =
         browser()->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(initiator);
     ASSERT_NE(tab, initiator);
   }
 
   // Resets the test so that another web page can be printed. It also deletes
   // the duplicated tab as it isn't needed anymore.
@@ skipping 28 matching lines @@
 
     // Redirects |std::cin| to the file |stdin_path|. |in| is not freed because
     // if it goes out of scope, |std::cin.rdbuf| will be freed, causing an
     // error.
     std::ifstream* in = new std::ifstream(stdin_path.value().c_str());
     ASSERT_TRUE(in->is_open());
     std::cin.rdbuf(in->rdbuf());
 
     pdf_file_save_path_ =
         tmp_dir_.path().Append(FILE_PATH_LITERAL("dummy.pdf"));
+    ASSERT_FALSE(pdf_file_save_path_.empty());

[Lei Zhang, 2014/07/22 03:04:39]

This can't be false, you just appended to it one line above. Rather,
PrintPreviewObserver(), which is the consumer of |pdf_file_save_path_| should
sanity check this.

[ivandavid, 2014/07/22 19:02:00]

Done.

[ivandavid, 2014/07/22 19:02:00]

I moved this to ManipulatePreviewSettings() when |observer_| is in the
kWaitingForFinalMessage state.

 
     // Send the file path to the layout test framework so that it can
     // communicate with this browser test.
     std::cout << "StdinPath: " << stdin_path.value() << "\n";
     std::cout << "#EOF\n";
     std::cout.flush();
   }
 
  private:
   // Generates a png from bitmap data and stores it in |png_output_|.
@@ skipping 134 matching lines @@
         cmd.find(file_extension) != base::FilePath::StringType::npos);
 
     // Splits the command sent by the layout test framework. The first command
     // is always the file path to use for the test. The rest isn't relevant,
     // so it can be ignored. The separator for the commands is an apostrophe.
     std::vector<base::FilePath::StringType> cmd_arguments;
     base::SplitString(cmd, '\'', &cmd_arguments);
 
     ASSERT_GE(cmd_arguments.size(), 1U);
     base::FilePath::StringType test_name(cmd_arguments[0]);
-    NavigateAndPreview(test_name, settings);
-    Print();
+    NavigateAndPrint(test_name, settings);
     PdfToPng();
 
     // Message to the layout test framework indicating that it should start
     // waiting for the image data, as there is no more text data to be read.
     // There actually isn't any text data at all, however because the layout
     // test framework requires it, a message has to be sent to stop it from
     // waiting for this message and start waiting for the image data.
     std::cout << "#EOF\n";
     std::cout.flush();
 
     SendPng();
     Reset();
   }
 }
 
 }  // namespace printing