Added a test that currently is able to print to pdf.

chrome/browser/printing/print_preview_pdf_generated_browsertest.cc

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.

[Lei Zhang, 2014/06/24 21:24:58]

No (c), forgot to tell you last time.

[ivandavid, 2014/06/24 22:55:48]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdio>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <vector>
+#include <unistd.h>
+
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/path_service.h"
+#include "base/run_loop.h"
+#include "base/strings/string_util.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/net/referrer.h"
+#include "chrome/browser/printing/print_preview_dialog_controller.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
+#include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
+#include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/print_messages.h"
+#include "chrome/common/url_constants.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_ui_message_handler.h"
+#include "content/public/common/page_transition_types.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_navigation_observer.h"
+#include "content/public/test/test_utils.h"
+#include "printing/print_job_constants.h"
+#include "ui/events/keycodes/keyboard_codes.h"
+#include "url/gurl.h"
+#include "ipc/ipc_message_macros.h"
+
+using content::WebContents;
+using content::WebContentsObserver;
+
+class PrintPreviewObserver;
+class UIDoneLoadingMessageHandler;
+
+// Message refers to the 'UILoaded' message from print_preview.js.
+// It gets sent either from onPreviewGenerationDone or from
+// onManipulateSettings_() in print_preview.js
+enum State {
+  // Waiting for the first message so the program can select Save as PDF
+  kWaitingToSendSaveAsPdf = 0,
+  // Waiting for the second message so the test can set the layout
+  kWaitingToSendLayoutSettings = 1,
+  // Waiting for the third message so the test can set the page numbers
+  kWaitingToSendPageNumbers = 2,
+  // Waiting for the forth message so the test can set the headers checkbox
+  kWaitingToSendHeadersAndFooters = 3,
+  // Waiting for the fifth message so the test can set the background checkbox
+  kWaitingToSendBackgroundColorsAndImages = 4,
+  // Waiting for the sixth message so the test can set the margins combobox
+  kWaitingToSendMargins = 5,
+  // Waiting for the final message so the program can save to PDF.
+  kWaitingForFinalMessage = 6,
+};
+
+class PrintPreviewObserver : public WebContentsObserver {
+ public:
+  PrintPreviewObserver(WebContents* dialog, Browser* browser)
+      : WebContentsObserver(dialog), browser_(browser), is_portrait_(true),
+        headers_and_footers_(true), background_colors_and_images_(false),
+        margins_(printing::DEFAULT_MARGINS) {}

[Dan Beam, 2014/06/24 22:55:16]

nit: each on a separate line

[ivandavid, 2014/06/25 00:02:21]

Done.

+
+  virtual ~PrintPreviewObserver() {}
+
+  // Sets closure for the observer so that it can end the loop.
+  void set_quit_closure(const base::Closure &closure) {
+    closure_ = closure;
+  }
+
+  // Actually stops the message_loop so that the test can proceed.
+  void EndLoop() {
+    base::MessageLoop::current()->PostTask(FROM_HERE, closure_);
+  }
+
+  bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    IPC_BEGIN_MESSAGE_MAP(PrintPreviewObserver, message)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPreviewPageCount,
+                          OnDidGetPreviewPageCount)
+      IPC_MESSAGE_UNHANDLED(return false;)
+    IPC_END_MESSAGE_MAP();
+    return false;
+  }
+
+  // Gets the PrintPreviewUI so that certain elements can be accessed.
+  PrintPreviewUI* GetUI() {
+    return ui_;
+  }
+
+  // Returns the web_contents of the print preview dialog.
+  WebContents* GetPreviewContents() {
+    return web_contents_;
+  }
+
+  // Calls a javascript function that will change the print preview settings,
+  // such as the layout, the margins, page numbers, etc.
+  void ManipulatePreviewSettings(State state) {
+    std::vector<const base::Value*> args;
+    script_argument_.reset(new base::DictionaryValue());
+    if (state == kWaitingToSendSaveAsPdf) {
+      script_argument_->SetBoolean("selectSaveAsPdfDestination", true);
+    } else if (state == kWaitingToSendLayoutSettings) {
+      script_argument_->SetBoolean("layoutSettings.portrait", is_portrait_);
+    } else if (state == kWaitingToSendPageNumbers) {
+      script_argument_->SetString("pageRange", page_numbers_);
+    } else if (state == kWaitingToSendHeadersAndFooters) {
+      script_argument_->SetBoolean("headersAndFooters", headers_and_footers_);
+    } else if (state == kWaitingToSendBackgroundColorsAndImages) {
+      script_argument_->SetBoolean("backgroundColorsAndImages",
+                                   background_colors_and_images_);
+    } else if (state == kWaitingToSendMargins) {
+      script_argument_->SetInteger("margins", margins_);
+    }
+
+    args.push_back(script_argument_.get());
+    DCHECK(!script_argument_->empty());
+    DCHECK(!args.empty());
+    ui_->web_ui()->CallJavascriptFunction("onManipulateSettingsForTest", args);
+  }
+
+  // Function to set the print preview settings and save them so they
+  // can be sent later. Currently only used in the constructor. Will be
+  // used when creating a test and take command line arguments.
+  // |page_numbers| is a comma separated page range.
+  //    Example: "1-5,9" will print pages 1 through 5 and page 9.
+  //    The pages specified must be less than or equal to the maximum
+  //    page number. An empty string seems to be valid input, however
+  //    further testing will be required to see if that is actually
+  //    true.
+  void SetPrintPreviewSettings(bool is_portrait,
+                               const std::string& page_numbers,
+                               bool headers_and_footers,
+                               bool background_colors_and_images,
+                               printing::MarginType margins) {
+    is_portrait_ = is_portrait;
+    page_numbers_ = page_numbers;
+    headers_and_footers_ = headers_and_footers;
+    background_colors_and_images_ = background_colors_and_images;
+    margins_ = margins;
+  }
+
+ private:
+  // Called when the observer gets the IPC message stating that the
+  // page count is ready.
+  void OnDidGetPreviewPageCount(
+      const PrintHostMsg_DidGetPreviewPageCount_Params &params);
+
+  void DidCloneToNewWebContents(WebContents* old_web_contents,
+                                WebContents* new_web_contents)
+                                OVERRIDE {
+    Observe(new_web_contents);

[Lei Zhang, 2014/06/24 21:24:58]

In patch set 16, I asked if this should only be called once.

[ivandavid, 2014/06/24 22:55:48]

I think I'll just leave it like it is for now, but I will attempt to add a check
later.

+  }
+
+  void WebContentsDestroyed() OVERRIDE {
+    EndLoop();
+  }
+
+  Browser* browser_;
+  base::Closure closure_;
+  WebContents* web_contents_;

[Dan Beam, 2014/06/24 22:55:16]

not initialized, would crash if dereferenced

[ivandavid, 2014/06/25 00:02:21]

Done.

[ivandavid, 2014/06/25 00:02:21]

Removed the variable. Turns out it was unnecessary.

+
+  PrintPreviewUI* ui_;

[Dan Beam, 2014/06/24 22:55:16]

not initialized, would crash if deferenced

[ivandavid, 2014/06/25 00:02:21]

Same change as for web_contents_. 
Done.

+
+  scoped_ptr<PrintPreviewObserver> print_preview_observer_;

[Lei Zhang, 2014/06/24 21:24:58]

Why does PrintPreviewObserver own another PrintPreviewObserver?

[ivandavid, 2014/06/24 22:55:48]

I think it was a copy paste accident.

[ivandavid, 2014/06/24 22:55:48]

Done.

+  scoped_ptr<base::DictionaryValue> script_argument_;
+  bool is_portrait_;
+  std::string page_numbers_;
+  bool headers_and_footers_;
+  bool background_colors_and_images_;
+  printing::MarginType margins_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewObserver);
+};
+
+class UIDoneLoadingMessageHandler : public content::WebUIMessageHandler {
+ public:
+  explicit UIDoneLoadingMessageHandler(PrintPreviewObserver* observer) :
+      observer_(observer), state_(kWaitingToSendSaveAsPdf) {}
+
+  virtual ~UIDoneLoadingMessageHandler() {
+    observer_ = NULL;
+  }
+
+  void HandleDone(const base::ListValue* /* args */) {
+    if (state_ == kWaitingForFinalMessage) {
+      observer_->EndLoop();
+    } else {
+      observer_->ManipulatePreviewSettings(state_);
+      state_ = static_cast<State>(static_cast<int>(state_) + 1);
+    }
+  }
+
+  void HandleFailure(const base::ListValue* /* args */) {
+    FAIL();
+  }
+
+  void RegisterMessages() OVERRIDE {
+    web_ui()->RegisterMessageCallback(
+    "UILoadedForTest",
+    base::Bind(&UIDoneLoadingMessageHandler::HandleDone,
+               base::Unretained(this)));
+
+    web_ui()->RegisterMessageCallback(
+    "UIFailedLoadingForTest",
+    base::Bind(&UIDoneLoadingMessageHandler::HandleFailure,
+               base::Unretained(this)));
+  }
+
+ private:
+  PrintPreviewObserver* observer_;
+  State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(UIDoneLoadingMessageHandler);
+};
+
+void PrintPreviewObserver::OnDidGetPreviewPageCount(
+    const PrintHostMsg_DidGetPreviewPageCount_Params &params) {
+
+  WebContents* tab = browser_->tab_strip_model()->GetActiveWebContents();
+  ASSERT_TRUE(tab);
+  printing::PrintPreviewDialogController* dialog_controller =
+      printing::PrintPreviewDialogController::GetInstance();
+  ASSERT_TRUE(dialog_controller);
+  web_contents_ = dialog_controller->GetPrintPreviewForContents(tab);
+  ASSERT_TRUE(web_contents_);
+  ASSERT_TRUE(printing::PrintPreviewDialogController::
+      IsPrintPreviewDialog(web_contents_));
+  ui_ = static_cast<PrintPreviewUI*>(web_contents_->GetWebUI()->
+      GetController());
+  ASSERT_TRUE(ui_);
+  ASSERT_TRUE(ui_->web_ui());
+  ui_->web_ui()->CallJavascriptFunction("onEnableManipulateSettingsForTest");
+  Observe(web_contents_);
+  UIDoneLoadingMessageHandler* handler = new UIDoneLoadingMessageHandler(this);
+  ui_->web_ui()->AddMessageHandler(handler);
+}
+
+class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
+ public:
+  PrintPreviewPdfGeneratedBrowserTest() {}
+  virtual ~PrintPreviewPdfGeneratedBrowserTest() {}
+
+  // TODO (ivandavid): Provide arguments for SetPrintPreviewSettings here.
+  void NavigateAndPreview(const base::FilePath::StringType& file_name) {
+    print_preview_observer_->SetPrintPreviewSettings(false,
+                            "",
+                            false,
+                            false,
+                            printing::DEFAULT_MARGINS);
+    base::FilePath directory(FILE_PATH_LITERAL("printing"));
+    base::FilePath file(file_name);
+    ui_test_utils::NavigateToURL(browser(),
+                                 ui_test_utils::GetTestUrl(directory, file));
+
+    base::RunLoop loop;
+    print_preview_observer_->set_quit_closure(loop.QuitClosure());
+    chrome::Print(browser());
+    loop.Run();
+  }
+
+  void Print() {
+    base::FilePath pdf_file_save_path;
+    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &pdf_file_save_path));
+    pdf_file_save_path = pdf_file_save_path.AppendASCII("printing");
+    pdf_file_save_path = pdf_file_save_path.AppendASCII("dummy.pdf");
+
+    base::RunLoop loop;
+    print_preview_observer_->set_quit_closure(loop.QuitClosure());
+    print_preview_observer_->GetUI()->handler_->
+        FileSelected(pdf_file_save_path, 0, NULL);
+    loop.Run();
+  }
+
+ private:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    WebContents* tab =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    ASSERT_TRUE(tab);
+
+    print_preview_observer_.reset(new PrintPreviewObserver(tab, browser()));
+    chrome::DuplicateTab(browser());
+
+    WebContents* initiator_ =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    ASSERT_TRUE(initiator_);
+    ASSERT_NE(tab, initiator_);
+  }
+
+  virtual void CleanUpOnMainThread() OVERRIDE {
+    print_preview_observer_.reset();
+  }
+
+  scoped_ptr<PrintPreviewObserver> print_preview_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewPdfGeneratedBrowserTest);
+};
+
+IN_PROC_BROWSER_TEST_F(PrintPreviewPdfGeneratedBrowserTest, DummyTest) {
+  // TODO(ivandavid): Make this work on Windows also. Windows doesn't have
+  // the same directory structure.
+
+  // If the layout tests are run and then this test is run in isolation, it
+  // will behave as if the layout test framework launched it, because this
+  // file is not currently being cleaned up by the layout test framework.
+  // It will be fixed.
+  bool in_layout_test =
+      freopen("/tmp/pdf_generated_browsertest/stdin.txt", "r", stdin)

[Lei Zhang, 2014/06/24 21:24:58]

Don't do this. It's hacky. I think this test should always be in layout test
mode anyway. You'd want to change DummyTest to DISABLED_DummyTest, so it does
not run as part of the normal browser_tests suite. Instead, you would only run
it from the layout test runner, where you can pass
--gtest_also_run_disabled_tests
--gtest_filter=rintPreviewPdfGeneratedBrowserTest.DummyTest.

[ivandavid, 2014/06/24 22:55:48]

Done.

[ivandavid, 2014/06/24 22:55:48]

I made it so that it automatically assumes that its in the layout test, however
it doesn't currently cleanup itself correctly. It will once I've done more with
the layout testing.

+          ? true : false;
+  std::string cmd;
+
+  if (in_layout_test) {
+    // The printf and fflush is necessary as it seems to be necessary because
+    // otherwise, the layout tests don't seem to get it if I just use logs or
+    // if I just do printf and no fflush().
+    printf("#READY\n");
+    fflush(stdout);
+
+    // Might have to rewrite this one. It might not work in every case.
+    // Works for now though.
+    getline(std::cin, cmd);

[Lei Zhang, 2014/06/24 21:24:58]

std::getline, so you don't confuse this with getline from stdio.h.

[ivandavid, 2014/06/24 22:55:48]

Done.

+    if (cmd.size() == 0) {

[Lei Zhang, 2014/06/24 21:24:58]

std::string::size() == 0 -> std::string::empty()

similarly,

std::string::size() > 0 -> !std::string::empty()

[ivandavid, 2014/06/24 22:55:48]

Done.

+      while (std::cin.eof()) {
+        std::cin.clear();
+        getline(std::cin, cmd);
+        if (cmd.size() > 0) {
+          LOG(ERROR) << cmd;
+          break;
+        }
+      }
+    } else {
+      LOG(ERROR) << cmd;
+    }
+  }
+
+  // TODO(ivandavid): Read from cmd the name of the test html file.

[Lei Zhang, 2014/06/24 21:24:58]

If you want to be content_shell compatible, you may need to read in multiple
test file names and run multiple "layout tests" right?

[ivandavid, 2014/06/24 22:55:48]

I am not completely sure how it works when running multiple tests as I've only
been running one at a time. However, I think for each test, it spawns a new
thread. So if we wanted to test two different webpages, it would create two
instances of this browsertest. So I think it only needs to read one test file.
I'm going to have to do more tests to figure this out and will change it if need
be.

+  base::FilePath::StringType test_name("test2.html");
+  NavigateAndPreview(test_name);
+  Print();
+
+  // Tells the layout tests that everything is done.
+  // In the future, before this part, PNG data will be sent from this program
+  // to the layout tests through stdout.
+  if (in_layout_test) {
+    printf("#EOF\n");
+    fflush(stdout);
+
+    // Send image data before this EOF.
+    printf("#EOF\n");
+    fflush(stdout);
+    fprintf(stderr, "#EOF\n");
+  }
+}