Add a browser test that can communicate with the layout test framework and print pdfs.

chrome/browser/printing/print_preview_pdf_generated_browsertest.cc

Index: chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
diff --git a/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc b/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5aaa65786f040d00a854e5e310464f9437ea482d
--- /dev/null
+++ b/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
@@ -0,0 +1,725 @@
+// 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 <cstdio>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if defined(OS_WIN)

[Lei Zhang, 2014/07/17 00:30:37]

Chromium style is to put platform-specific #includes after all the general
#includes.

[ivandavid, 2014/07/17 20:49:20]

Done.

+#include <fcntl.h>
+#include <io.h>
+#endif
+
+#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/format_macros.h"
+#include "base/logging.h"
+#include "base/md5.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/path_service.h"
+#include "base/run_loop.h"
+#include "base/scoped_native_library.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.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 "ipc/ipc_message_macros.h"
+#include "net/base/filename_util.h"
+#include "printing/pdf_render_settings.h"
+#include "printing/units.h"
+#include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/geometry/rect.h"
+#include "url/gurl.h"
+
+using content::WebContents;
+using content::WebContentsObserver;
+
+namespace printing {
+
+// Number of color channels in a BGRA bitmap.
+const int kColorChannels = 4;
+const int kDpi = 300;
+
+// Every state is used when the document is a non-PDF source. When the source is
+// a PDF, kWaitingToSendSaveAsPDF, kWaitingToSendPageNumbers, and
+// kWaitingForFinalMessage are the only states used.
+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,
+};
+
+// Settings for print preview. It reflects the current options provided by
+// print preview. If more options are added, more states should be added and
+// there should be more settings added to this struct.
+struct PrintPreviewSettings {
+  PrintPreviewSettings(bool is_portrait,
+                       std::string page_numbers,
+                       bool headers_and_footers,
+                       bool background_colors_and_images,
+                       MarginType margins,
+                       bool is_already_pdf)
+      : is_portrait(is_portrait),
+        page_numbers(page_numbers),
+        headers_and_footers(headers_and_footers),
+        background_colors_and_images(background_colors_and_images),
+        margins(margins),
+        is_already_pdf(is_already_pdf) {}
+
+  bool is_portrait;
+  std::string page_numbers;
+  bool headers_and_footers;
+  bool background_colors_and_images;
+  MarginType margins;
+  bool is_already_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)
+      : WebContentsObserver(dialog),
+        browser_(browser),
+        state_(kWaitingToSendSaveAsPdf),
+        failed_setting_("None") {}
+
+  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() {
+    base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
+  }
+
+  bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    IPC_BEGIN_MESSAGE_MAP(PrintPreviewObserver, message)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPreviewPageCount,
+                          OnDidGetPreviewPageCount)
+    IPC_END_MESSAGE_MAP();
+    return false;
+  }
+
+  // Gets the web contents for the print preview dialog so that the UI and
+  // other elements can be accessed.
+  WebContents* GetDialog() {
+    WebContents* tab = browser_->tab_strip_model()->GetActiveWebContents();
+    PrintPreviewDialogController* dialog_controller =
+        PrintPreviewDialogController::GetInstance();
+    WebContents* web_contents =
+        dialog_controller->GetPrintPreviewForContents(tab);
+    return web_contents;
+  }
+
+  // Gets the PrintPreviewUI so that certain elements can be accessed.
+  PrintPreviewUI* GetUI() {
+    return static_cast<PrintPreviewUI*>(
+        GetDialog()->GetWebUI()->GetController());
+  }
+
+  // Calls native_layer.onManipulateSettingsForTest() and sends a dictionary
+  // value containing the type of setting and the value to set that settings
+  // to.
+  void ManipulatePreviewSettings() {
+    base::DictionaryValue script_argument;
+
+    if (state_ == kWaitingToSendSaveAsPdf) {
+      script_argument.SetBoolean("selectSaveAsPdfDestination", true);
+      state_ = settings_->is_already_pdf ?
+               kWaitingToSendPageNumbers : kWaitingToSendLayoutSettings;
+      failed_setting_ = "Save as PDF";
+    } else if (state_ == kWaitingToSendLayoutSettings) {
+      script_argument.SetBoolean("layoutSettings.portrait",
+                                 settings_->is_portrait);
+      state_ = kWaitingToSendPageNumbers;
+      failed_setting_ = "Layout Settings";
+    } else if (state_ == kWaitingToSendPageNumbers) {
+      script_argument.SetString("pageRange", settings_->page_numbers);
+      state_ = settings_->is_already_pdf ?
+               kWaitingForFinalMessage : kWaitingToSendHeadersAndFooters;
+      failed_setting_ = "Page Range";
+    } else if (state_ == kWaitingToSendHeadersAndFooters) {
+      script_argument.SetBoolean("headersAndFooters",
+                                 settings_->headers_and_footers);
+      state_ = kWaitingToSendBackgroundColorsAndImages;
+      failed_setting_ = "Headers and Footers";
+    } 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();
+      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) {
+    settings_.reset(new PrintPreviewSettings(settings));
+  }
+
+  // Returns the setting that could not be set in the preview dialog.
+  std::string GetFailedSetting() {

[Lei Zhang, 2014/07/17 00:30:36]

Why not just have a big if/else block here?

if (state_ == foo)
  return "blah";
else if (...)
  return "..."

and avoid needing |failed_setting_| altogether?

[ivandavid, 2014/07/17 20:49:20]

I already tried that, but it ended up being too large. The problem is that there
are multiple 'paths' in the state machine depending on the source. If the source
is an html file and |state_| is |kWaitingForFinalMessage| then the setting that
failed is the margins setting, however if the source is a PDF, the failed
setting is the page range. This could get more and more complicated as settings
are added or more source files or something like that. |failed_setting_| is easy
to use because it doesn't matter what source file is being used or what settings
can/can't be sent.

+    return failed_setting_;
+  }
+
+ private:
+  // Listens for messages from the print preview dialog. Specifically, it
+  // listens for 'UILoadedForTest' and 'UIFailedLoadingForTest.'
+  class UIDoneLoadingMessageHandler : public content::WebUIMessageHandler {
+   public:
+    explicit UIDoneLoadingMessageHandler(PrintPreviewObserver* observer)
+        : observer_(observer) {}
+
+    virtual ~UIDoneLoadingMessageHandler() {}
+
+    // When a setting has been set succesfully, this is called and the observer
+    // is told to send the next setting to be set.
+    void HandleDone(const base::ListValue* /* args */) {
+      ASSERT_TRUE(observer_);
+      observer_->ManipulatePreviewSettings();
+    }
+
+    // Ends the test because a setting was not set successfully. Called when
+    // this class hears 'UIFailedLoadingForTest.'
+    void HandleFailure(const base::ListValue* /* args */) {
+      FAIL() << "Failed to set: " << observer_->GetFailedSetting();
+    }
+
+    // Allows this class to listen for the 'UILoadedForTest' and
+    // 'UIFailedLoadingForTest' messages. These messages are sent by the print
+    // preview dialog. 'UILoadedForTest' is sent when a setting has been
+    // successfully set and its effects have been finalized.
+    // 'UIFailedLoadingForTest' is sent when the setting could not be set. This
+    // causes the browser test to 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 * const observer_;
+
+    DISALLOW_COPY_AND_ASSIGN(UIDoneLoadingMessageHandler);
+  };
+
+  // Called when the observer gets the IPC message stating that the page count
+  // is ready.
+  void OnDidGetPreviewPageCount(
+        const PrintHostMsg_DidGetPreviewPageCount_Params &params) {
+    WebContents* web_contents = GetDialog();
+    PrintPreviewUI* ui = GetUI();
+    ASSERT_TRUE(ui);
+    ASSERT_TRUE(ui->web_ui());
+    Observe(web_contents);
+    ASSERT_TRUE(web_contents);
+
+    // The web ui deallocates the memory for the handler when |ui| is destroyed

[Lei Zhang, 2014/07/17 00:30:37]

Just say |ui->web_ui()| owns the message handler.

[ivandavid, 2014/07/17 20:49:20]

Done.

[Lei Zhang, 2014/07/17 21:08:16]

Not done. And neither is anything else below that you replied "done" to.

+    // so we don't have to worry about it.
+    ui->web_ui()->AddMessageHandler(new UIDoneLoadingMessageHandler(this));
+    ui->web_ui()->CallJavascriptFunction("onEnableManipulateSettingsForTest");
+  }
+
+  void DidCloneToNewWebContents(WebContents* old_web_contents,
+                                WebContents* new_web_contents) OVERRIDE {
+    Observe(new_web_contents);
+  }
+
+  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_;
+
+  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,
+                          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_, 0, NULL);
+    loop.Run();
+    // Checks to see if the file that was created is readable/available. There
+    // is a bug on windows and linux where even though the loop ended, the file
+    // isn't can't be read for a while, even though the path exists. This solves

[Lei Zhang, 2014/07/17 00:30:37]

typo: "isn't can't"

[ivandavid, 2014/07/17 20:49:20]

Done.

+    // that by polling to see if the file can be opened or read.
+    // TODO(ivandavid): Find a better way to poll for the file.
+    while (true) {

[Lei Zhang, 2014/07/17 00:30:36]

If |pdf_file_save_path_| doesn't actually exist, wouldn't this infinite loop
until the test times out?

[ivandavid, 2014/07/17 20:49:19]

Done.

+      base::File pdf_file(
+          pdf_file_save_path_, base::File::FLAG_OPEN | base::File::FLAG_READ);
+      if (pdf_file.IsValid())
+          break;
+    }
+  }
+
+  // Initializes the pdf libfunctions. Called once when browser test starts.

[Lei Zhang, 2014/07/17 00:30:36]

"the pdf libfunctions" -> "function pointers from the PDF library"

[ivandavid, 2014/07/17 20:49:20]

Done.

+  // 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());
+    pdf_to_bitmap_func_ =
+        reinterpret_cast<PDFPageToBitmapProc>(
+            pdf_lib_.GetFunctionPointer("RenderPDFPageToBitmap"));
+
+    pdf_doc_info_func_ =
+        reinterpret_cast<GetPDFDocInfoProc>(
+            pdf_lib_.GetFunctionPointer("GetPDFDocInfo"));
+
+    pdf_page_size_func_ =
+        reinterpret_cast<GetPDFPageSizeByIndexProc>(
+            pdf_lib_.GetFunctionPointer("GetPDFPageSizeByIndex"));
+
+    ASSERT_TRUE(pdf_to_bitmap_func_);
+    ASSERT_TRUE(pdf_doc_info_func_);
+    ASSERT_TRUE(pdf_page_size_func_);
+  }
+
+  // Converts the PDF to a PNG file so that the layout test can do an image
+  // diff on this image and a reference image.
+  void PdfToPng() {
+    int num_pages;
+    double max_width_in_points = 0;
+    std::vector<uint8_t> bitmap_data;
+    double total_height_in_pixels = 0;
+    std::string data;

[Lei Zhang, 2014/07/17 00:30:37]

data -> pdf_data ?

[ivandavid, 2014/07/17 20:49:20]

Done.

+
+    ASSERT_TRUE(base::PathExists(pdf_file_save_path_));
+    ASSERT_TRUE(base::ReadFileToString(pdf_file_save_path_, &data));
+    ASSERT_TRUE(pdf_doc_info_func_(data.data(),
+                                   data.size(),
+                                   &num_pages,
+                                   &max_width_in_points));
+
+    ASSERT_GT(num_pages, 0);
+    double max_width_in_pixels =
+        ConvertPointsToPixelDouble(max_width_in_points);
+
+    for (int i = 0; i < num_pages; ++i) {
+      double width_in_points, height_in_points;
+      ASSERT_TRUE(pdf_page_size_func_(
+          data.data(), data.size(), i, &width_in_points, &height_in_points));
+
+      double width_in_pixels = ConvertPointsToPixelDouble(width_in_points);
+      double height_in_pixels = ConvertPointsToPixelDouble(height_in_points);
+
+      // The image will be rotated if |width_in_pixels| is greater than
+      // |height_in_pixels|. This is because the page will be rotated to fit
+      // within a piece of paper. Therefore, |width_in_pixels| and
+      // |height_in_pixels| have to be swapped or else they won't reflect the
+      // dimensions of the rotated page.
+      if (width_in_pixels > height_in_pixels)
+        std::swap(width_in_pixels, height_in_pixels);
+
+      total_height_in_pixels += height_in_pixels;
+      gfx::Rect rect(width_in_pixels, height_in_pixels);
+      PdfRenderSettings settings(rect, kDpi, true);
+
+      int int_max = std::numeric_limits<int>::max();
+      if (settings.area().width() > int_max / kColorChannels ||
+          settings.area().height() > int_max / (kColorChannels *
+              settings.area().width())) {
+        FAIL() << "The dimensions of the image are too large." <<

[Lei Zhang, 2014/07/17 00:30:37]

the last << should be on the next line.

FAIL() << "Foo"
       << "Bar";

[ivandavid, 2014/07/17 20:49:20]

Done.

+            "Decrease the DPI or the dimensions of the image.";
+      }
+
+      std::vector<uint8_t> page_bitmap_data(
+          kColorChannels * settings.area().size().GetArea());
+
+      ASSERT_TRUE(pdf_to_bitmap_func_(data.data(),
+                                      data.size(),
+                                      i,
+                                      page_bitmap_data.data(),
+                                      settings.area().size().width(),
+                                      settings.area().size().height(),
+                                      settings.dpi(),
+                                      settings.dpi(),
+                                      true));
+      FillPng(&page_bitmap_data,
+              width_in_pixels,
+              max_width_in_pixels,
+              settings.area().size().height());
+      bitmap_data.insert(bitmap_data.end(),
+                         page_bitmap_data.begin(),
+                         page_bitmap_data.end());
+    }
+
+    CreatePng(bitmap_data, max_width_in_pixels, total_height_in_pixels);
+  }
+
+  // Fills out a bitmap with whitespace so that the image will correctly fit
+  // within a PNG that is wider than the bitmap itself.
+  void FillPng(std::vector<uint8_t>* bitmap,
+               int current_width,
+               int desired_width,
+               int height) {
+    if (current_width < desired_width) {

[Lei Zhang, 2014/07/17 00:30:37]

Also assert: current_width <= desired_width. In which case, if you change this
to:

if (current_width == desired_width)
  return;  // Nothing to do

...

buys you one extra level of indentation.

[ivandavid, 2014/07/17 20:49:20]

Done.

+      ASSERT_TRUE(bitmap);

[Lei Zhang, 2014/07/17 00:30:37]

Check all the pre-conditions before doing any real work.

[ivandavid, 2014/07/17 20:49:20]

Done.

+
+      int current_width_in_bytes = current_width * kColorChannels;
+      int desired_width_in_bytes = desired_width * kColorChannels;
+      const uint8_t kColorByte = 255;
+      std::vector<uint8_t> filled_bitmap(
+          desired_width * kColorChannels * height, kColorByte);
+      std::vector<uint8_t>::iterator filled_bitmap_it = filled_bitmap.begin();
+      std::vector<uint8_t>::iterator bitmap_it = bitmap->begin();
+
+      for (size_t num_copied = 0; bitmap_it != bitmap->end(); ++bitmap_it) {
+        *filled_bitmap_it = *bitmap_it;

[Lei Zhang, 2014/07/17 00:30:36]

Rather than slowly copying this byte by byte, just do a memcpy() for the entire
row.

[ivandavid, 2014/07/17 22:27:46]

Done.

+        if (!(++num_copied % current_width_in_bytes)) {
+          num_copied = 0;
+          std::advance(filled_bitmap_it,
+                       desired_width_in_bytes - current_width_in_bytes + 1);
+        } else {
+          ++filled_bitmap_it;
+        }
+      }
+
+      bitmap->assign(filled_bitmap.begin(), filled_bitmap.end());
+    }
+  }
+
+  // Sends the PNG image to the layout test framework for comparison.
+  void SendPng() {
+    // Send image header and |hash_| to the layout test framework.
+    std::cout << "Content-Type: image/png\n";

[Lei Zhang, 2014/07/17 00:30:36]

Can you explain why you switched from print() to std::cout?

[ivandavid, 2014/07/17 20:49:20]

For compatibility reasons, I had to get rid of freopen() and instead allocate a
new |rdbuf| for it. To keep everything consistent, I changed everything to
std::cout and std::cerr. Also, on Windows when I tried using printf, the output
was not correct. It would only display 'C' rather than 'C:\foo\...', ie. the
path to the temporary file and directory.

+    std::cout << "ActualHash: " << base::MD5DigestToBase16(hash_) << "\n";
+    std::cout << "Content-Length: " << output_.size() << "\n";
+
+    for (size_t i = 0; i < output_.size(); ++i)
+      std::cout << output_[i];
+
+    std::cout << "#EOF\n";
+    std::cout.flush();
+    std::cerr << "#EOF\n";
+    std::cerr.flush();
+  }
+
+  // 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));
+    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.
+  void Reset() {
+    output_.clear();
+    ASSERT_EQ(browser()->tab_strip_model()->count(), 2);
+    chrome::CloseTab(browser());
+    ASSERT_EQ(browser()->tab_strip_model()->count(), 1);
+  }
+
+  // Creates a temporary directory to store a text file that will be used for
+  // stdin to accept input from the layout test framework. A path for the PDF
+  // file is also created. The directory and files within it are automatically
+  // cleaned up once the test ends.
+  void SetupStdinAndSavePath() {
+    // Need to set the output to binary mode on Windows to avoid sending CRLF.
+    // The layout tests expected LF, not CRLF and will print error messages
+    // is CRLF is sent.
+#if defined(OS_WIN)
+    _setmode(_fileno(stdout), _O_BINARY);
+    _setmode(_fileno(stderr), _O_BINARY);
+#endif
+    // Sends a message to the layout test framework indicating indicating
+    // that the browser test has completed setting itself up. The layout
+    // test will then expect the file path for stdin.
+    base::FilePath tmp_path;
+    std::cout << "#READY\n";
+    std::cout.flush();
+
+    ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
+    ASSERT_TRUE(base::CreateTemporaryFileInDir(tmp_dir_.path(), &tmp_path));
+    std::ifstream* in = new std::ifstream(tmp_path.value().c_str());

[Lei Zhang, 2014/07/17 00:30:36]

Who frees |in| ?

[ivandavid, 2014/07/17 20:49:19]

It should not be freed. If the |in| is ever freed, the buffer passed into
|std::cin| will disappear, causing everything to not work. Unlike |std::cin|,
|rdbuf| for |std::ifstream| cannot be set, if it could, I would set |in|'s
|rdbuf| to NULL after passing the original buffer to |std::cin|, that way it
won't get deallocated when |in| goes out if scope. I also tried using
std::ios::rdbuf on |in| to set |rdbuf| to NULL and it didn't work. This isn't
really a problem though, since |in| is only created once and it should exist for
the entire duration of the test, so it never really needs to be explicitly
freed. Also, since SIGKILL ends the test, there would never be an opportunity to
free it.

[Lei Zhang, 2014/07/17 23:31:05]

Can you add a (less verbose) comment to the code explain this?

+    ASSERT_TRUE(in->is_open());
+    std::cin.rdbuf(in->rdbuf());
+
+    pdf_file_save_path_ =
+        tmp_dir_.path().Append(FILE_PATH_LITERAL("dummy.pdf"));
+
+    // Send the file path to the layout test framework so that it can
+    // communicate with this browser test.
+    std::cout << "StdinPath: " << tmp_path.value() << "\n";
+    std::cout << "#EOF\n";
+    std::cout.flush();
+  }
+
+ private:
+  // Generates a png from bitmap data and stores it in |output_|.
+  void CreatePng(
+        const std::vector<uint8_t>& bitmap_data, int width, int height) {
+    std::string hash_data(bitmap_data.begin(), bitmap_data.end());
+    base::MD5Sum(
+        static_cast<const void*>(hash_data.data()), hash_data.size(), &hash_);
+
+    gfx::Rect png_rect(width, height);
+
+    // tEXtchecksum looks funny, but that's what the layout test framework
+    // expects.
+    std::string comment_title("tEXtchecksum\x00");
+    gfx::PNGCodec::Comment hash_comment(comment_title,
+                                        base::MD5DigestToBase16(hash_));
+
+    std::vector<gfx::PNGCodec::Comment> comments;
+    comments.push_back(hash_comment);
+
+    ASSERT_TRUE(gfx::PNGCodec::Encode(bitmap_data.data(),
+                                      gfx::PNGCodec::FORMAT_BGRA,
+                                      png_rect.size(),
+                                      png_rect.size().width() * kColorChannels,
+                                      false,
+                                      comments,
+                                      &output_));
+  }
+
+  scoped_ptr<PrintPreviewObserver> print_preview_observer_;
+  base::FilePath pdf_file_save_path_;
+
+  // These typedefs are function pointers to pdflib functions that give
+  // information about the PDF as a whole and about specific pages.
+
+  // Converts the PDF to a bitmap.
+  typedef bool (*PDFPageToBitmapProc)(const void* pdf_buffer,
+                                      int pdf_buffer_size,
+                                      int page_number,
+                                      void* bitmap_buffer,
+                                      int bitmap_width,
+                                      int bitmap_height,
+                                      int dpi_x,
+                                      int dpi_y,
+                                      bool autorotate);
+
+  // Gets the page count and maximum page width of the PDF in points.
+  typedef bool (*GetPDFDocInfoProc)(const void* pdf_buffer,
+                                    int buffer_size,
+                                    int* pages_count,
+                                    double* max_page_width);
+
+  // Gets the dimensions of a specific page within a PDF.
+  typedef bool (*GetPDFPageSizeByIndexProc)(const void* pdf_buffer,
+                                            int buffer_size,
+                                            int index,
+                                            double* width,
+                                            double* height);
+
+  // Instantiations of the function pointers described above.
+  PDFPageToBitmapProc pdf_to_bitmap_func_;
+  GetPDFDocInfoProc pdf_doc_info_func_;
+  GetPDFPageSizeByIndexProc pdf_page_size_func_;
+
+  // Used to open up the libpdf.so, which contains the functions above.
+  base::ScopedNativeLibrary pdf_lib_;
+
+  // Vector for storing the PNG to be sent to the layout test framework.
+  std::vector<unsigned char> output_;
+
+  // Image hash of the bitmap that is turned into a PNG. The hash is put into
+  // the PNG as a comment, as it is needed by the layout test framework.
+  base::MD5Digest hash_;
+
+  // Temporary directory for storing the pdf and the file for stdin.
+  base::ScopedTempDir tmp_dir_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewPdfGeneratedBrowserTest);
+};
+
+IN_PROC_BROWSER_TEST_F(PrintPreviewPdfGeneratedBrowserTest,
+                       MANUAL_DummyTest) {
+  // What this code is supposed to do:
+  // - Setup communication with the layout test framework
+  // - Print webpage to a pdf
+  // - Convert pdf to a png
+  // - Send png to layout test framework, where it doesn an image diff
+  //   on the image sent by this test and a reference image.
+  //
+  // Throughout this code, there will be printf statements. The layout test
+  // framework uses stdout to get data from the browser test and uses stdin
+  // to send data to the browser test. Calling std::cout<<"EOF\n" indicates that

[Lei Zhang, 2014/07/17 00:30:36]

Calling ... indicates -> Writing "EOF\n" to std::cout indicates

[ivandavid, 2014/07/17 20:49:19]

Done.

+  // whatever block of data that the test was expecting has been completely
+  // sent. Sometimes EOF is printed to stderr because the test will expect it
+  // from stderr in addition to stdout for certain blocks of data.
+  // "\n" is used instead of std::endl because that's how content shell does it.
+  // std::endl automatically flushes the buffer, which is something that
+  // shouldn't happen automatically.
+  InitPdfFunctions();
+  SetupStdinAndSavePath();
+
+  // There is no way to determine how many tests are to be run ahead of time
+  // without undesirable changes to the layout test framework. However, that is
+  // ok since whenever all the tests have been run, the layout test framework
+  // calls SIGKILL on this process, ending the test. This will end the while
+  // loop and cause the test to clean up after itself. For this to work, the
+  // browsertest must be run with '--single_process' not '--single-process.'
+  while (true) {
+    std::string input;
+    std::getline(std::cin, input);
+    if (input.empty()) {
+      while (std::cin.eof()) {
+        std::cin.clear();
+        std::getline(std::cin, input);
+        if (!input.empty()) {
+          break;
+        }
+      }
+    }
+
+#if defined(OS_POSIX)

[Lei Zhang, 2014/07/17 00:30:37]

You don't need the temp variables:

base::FilePath::StringType file_extension = FILE_PATH_LITERAL(".pdf");
base::FilePath::StringType cmd;
#if defined(OS_WIN)
cmd = base::UTF8ToUTF16(input);
#elif defined(OS_POSIX)
cmd = input;
#endif

[ivandavid, 2014/07/17 20:49:20]

Done.

+    base::FilePath::StringType file_extension(".pdf");
+    base::FilePath::StringType cmd(input);
+#elif defined(OS_WIN)
+    base::StringPiece temp_cmd(input);
+    base::FilePath::StringType cmd = base::UTF8ToWide(temp_cmd);
+    base::StringPiece temp_file_extension(".pdf");
+    base::FilePath::StringType file_extension =
+        base::UTF8ToWide(temp_file_extension);
+#endif
+
+    DuplicateTab();
+    PrintPreviewSettings settings(
+        true,
+        "",
+        false,
+        false,
+        DEFAULT_MARGINS,
+        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);
+
+    // 1 Needs to be cast because ASSERT_GE can't compare unsigned and signed

[Lei Zhang, 2014/07/17 00:30:36]

No, write "1" and "1U".

[ivandavid, 2014/07/17 20:49:19]

Cool. I didn't know you could do that.

[ivandavid, 2014/07/17 20:49:20]

Done.

+    // numbers.
+    ASSERT_GE(cmd_arguments.size(), static_cast<size_t>(1));
+    base::FilePath::StringType test_name(cmd_arguments[0]);
+    NavigateAndPreview(test_name, settings);
+    Print();
+    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