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

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 <cstdio>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#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_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 "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"
+#include "ipc/ipc_message_macros.h"
+
+#if defined(OS_POSIX)
+#define STDIN_STREAM std::cin
+#elif defined(OS_WIN)
+#define STDIN_STREAM std::wcin
+#endif
+
+using content::WebContents;
+using content::WebContentsObserver;
+
+//Number of color channels in a BGRA bitmap.
+const int kColorChannels = 4;
+
+// 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,
+};
+
+// 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,
+                       printing::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;
+  printing::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(WebContents* dialog, Browser* browser)
+      : WebContentsObserver(dialog),
+        browser_(browser),
+        state_(kWaitingToSendSaveAsPdf) {}
+
+  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_);
+  }
+
+  // This method must always return false. If it ever returns true,
+  // it will cause the test to hang. This is because the
+  // PrintPreviewMessageHandler should still handle all of the messages to
+  // progress the print preview process.
+  bool OnMessageReceived(const IPC::Message& message) OVERRIDE {

[Dan Beam, 2014/07/09 02:08:31]

bool handled = true;

+    IPC_BEGIN_MESSAGE_MAP(PrintPreviewObserver, message)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPreviewPageCount,
+                          OnDidGetPreviewPageCount)
+      IPC_MESSAGE_UNHANDLED()

[Dan Beam, 2014/07/09 02:08:32]

IPC_MESSAGE_UNHANDLED(handled = false)

[ivandavid, 2014/07/09 19:58:22]

I just removed this line as it was never needed in the first place. This
function should always return false, no exceptions. This is because if it
returns true when the page count is received, the OnMessageReceived function in
print_preview_message_handler.cc never handles this message (I tested this to
make sure). This then causes the test to not progress. Since it should always
return false, there is no need to have that macro there, so I just removed it.

[Dan Beam, 2014/07/09 22:03:04]

ah, ok, if we don't to handle -- great, this totally works

+    IPC_END_MESSAGE_MAP();
+    return false;

[Dan Beam, 2014/07/09 02:08:32]

return handled;

+  }
+
+  // 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();
+    printing::PrintPreviewDialogController* dialog_controller =
+        printing::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 a javascript function that will change the print preview settings,
+  // such as the layout, the margins, page numbers, etc.
+  void ManipulatePreviewSettings() {
+    base::DictionaryValue script_argument;
+
+    if (state_ == kWaitingToSendSaveAsPdf) {
+      script_argument.SetBoolean("selectSaveAsPdfDestination", true);
+      state_ = settings_->is_already_pdf ?
+               kWaitingToSendPageNumbers :
+               kWaitingToSendLayoutSettings;
+    } else if (state_ == kWaitingToSendLayoutSettings) {
+      script_argument.SetBoolean("layoutSettings.portrait",
+                                  settings_->is_portrait);
+      state_ = kWaitingToSendPageNumbers;
+    } else if (state_ == kWaitingToSendPageNumbers) {
+      script_argument.SetString("pageRange", settings_->page_numbers);
+      state_ = settings_->is_already_pdf ?
+               kWaitingForFinalMessage :
+               kWaitingToSendHeadersAndFooters;
+    } else if (state_ == kWaitingToSendHeadersAndFooters) {
+      script_argument.SetBoolean("headersAndFooters",
+                                  settings_->headers_and_footers);
+      state_ = kWaitingToSendBackgroundColorsAndImages;
+    } else if (state_ == kWaitingToSendBackgroundColorsAndImages) {
+      script_argument.SetBoolean("backgroundColorsAndImages",
+                                   settings_->background_colors_and_images);
+      state_ = kWaitingToSendMargins;
+    } else if (state_ == kWaitingToSendMargins) {
+      script_argument.SetInteger("margins", settings_->margins);
+      state_ = kWaitingForFinalMessage;
+    } else if (state_ == kWaitingForFinalMessage) {
+      // Exit
+      EndLoop();
+      return;
+    }
+
+    ASSERT_TRUE(!script_argument.empty());
+    GetUI()->web_ui()->CallJavascriptFunction(
+        "onManipulateSettingsForTest", script_argument);
+  }
+
+  // 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(const PrintPreviewSettings& settings) {
+    settings_.reset(new PrintPreviewSettings(settings));
+  }
+
+ 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,
+    // therefore, the test shouldn't continue.
+    // TODO(ivandavid): Print out error message to give context.
+    void HandleFailure(const base::ListValue* /* args */) {
+      FAIL();
+    }
+
+    // Sets up this class to listen for the UILoadedForTest and
+    // UIFailedLoadingForTest messages. These messages are sent
+    // by print_preview.js. On UILoadedForTest, a settings has
+    // been successfully set and its effects on the pdf have been finalized.
+    // On UIFaieldLoadingForTest a setting has not been successfully set
+    // and the test should 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_;
+
+    DISALLOW_COPY_AND_ASSIGN(UIDoneLoadingMessageHandler);
+  };
+
+  // Called when the observer gets the IPC message stating that the
+  // page count is ready.
+  // Due to forward declaration problem, the definition of the function
+  // must be separated from the declaration.
+  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
+    // the web ui is destroyed.

[Dan Beam, 2014/07/09 02:08:32]

wrap as close to 80 cols as possible (everywhere)

[ivandavid, 2014/07/09 19:58:22]

Done.

[ivandavid, 2014/07/09 19:58:22]

I did my best to do this. Hopefully I caught most of 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 closure_;
+  scoped_ptr<PrintPreviewSettings> settings_;
+
+  // State of the observer. The state indicates what message it is
+  // to send next. The state advances whenever the message handler calls
+  // ManipulatePreviewSettings() on the observer.
+  State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewObserver);
+};
+
+class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
+ public:
+  PrintPreviewPdfGeneratedBrowserTest() {}
+  virtual ~PrintPreviewPdfGeneratedBrowserTest() {}
+
+  // Navigates to the web page given, then initiates print preview
+  // and waits for all the settings to be set.
+  void NavigateAndPreview(const base::FilePath::StringType& file_name,
+                          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 webpage to pdf, after the settings have been set.
+  void Print() {
+    ASSERT_FALSE(pdf_file_save_path_.empty());
+    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();
+  }
+
+  // Initializes the pdf lib functions. Called once when browser test starts.
+  // Library is closed when the 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() {
+    std::string data;
+    int num_pages;
+    const int kDpi = 300;
+    double max_width = 0;
+    std::vector<uint8_t> bitmap_data;
+    double total_height = 0;
+
+    ASSERT_TRUE(base::ReadFileToString(pdf_file_save_path_, &data));
+    ASSERT_TRUE(pdf_doc_info_func_(data.data(),
+                                   data.size(),
+                                   &num_pages,
+                                   &max_width));
+
+    max_width = printing::ConvertPointsToPixelDouble(max_width);
+
+    for (int i = 0; i < num_pages; ++i) {
+      double width, height;
+      bool autorotate = false;
+      ASSERT_TRUE(pdf_page_size_func_(
+          data.data(), data.size(), i, &width, &height));
+
+      width = printing::ConvertPointsToPixelDouble(width);
+      height = printing::ConvertPointsToPixelDouble(height);
+
+      // The image needs to be rotated if the width is > to the
+      // height. This is because, when the image is printed to a
+      // pdf, if it is in landscape mode (or the document is just wide)
+      // if will be printed horizontally, not vertically. However,
+      // if it printed, it would have been rotated. Therefore, the image
+      // has to be automatically rotated here to reflect what is printed.
+      //
+      // TODO (ivandavid): See if this is a linux only problem or if
+      // its on every platform. It might not matter, since if its
+      // autorotated, width > height will always be false.
+
+      if (width > height) {
+        std::swap<double>(width, height);
+        autorotate = true;
+      }
+
+      total_height += height;
+      gfx::Rect rect(width, height);
+      printing::PdfRenderSettings settings(rect, kDpi, true);
+
+      // TODO(ivandavid): Implement correct overflow detection.

[ivandavid, 2014/07/08 23:24:22]

I got rid of the old overflow detection because it wasn't correct. I'll redo it
later.

+      // Need to check for signed multiplication overflow.
+      // Can't use size_t or any unsigned stuff, b/c internally
+      // everything in PdfRenderSettings is signed it seems.
+
+      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(),
+                                      autorotate));
+
+      // Must multiply width & max_width by number of color channels because
+      // the bitmap stores individual bytes, not int32's.
+      FillPng(&page_bitmap_data, width * kColorChannels,
+              max_width * kColorChannels,
+              settings.area().size().height());
+      bitmap_data.insert(bitmap_data.end(),
+                         page_bitmap_data.begin(),
+                         page_bitmap_data.end());
+    }
+
+    CreatePng(bitmap_data, max_width, total_height);
+  }
+
+  // Fills out a bitmap with the color white to fit within a png
+  // that is wider than the bitmap. This prevents the image from
+  // being cutoff or split. The desired_width must be greater than
+  // the current width of the image.
+  void FillPng(std::vector<uint8_t>* bitmap,
+               int current_width,
+               int desired_width,
+               int height) {
+    // Need to seperate the iterator and index. We can't use an iterator only
+    // since the vector will most likely be resized and will render the
+    // iterator invalid. Might need to re-do to make it faster, but there
+    // don't seem to be any speed issues.
+    ASSERT_TRUE(bitmap);
+    ASSERT_LE(current_width, desired_width);
+    const uint8_t kColorByte = 255;
+    size_t index = 0;
+    for (int i = 0; i < height; ++i, index = i * desired_width) {
+      index += current_width - 1;
+      std::vector<uint8_t>::iterator iterator = bitmap->begin();
+      std::advance(iterator, index);
+      // 255,255,255,255 is white in BGRA
+      bitmap->insert(iterator, desired_width - current_width, kColorByte);
+    }
+  }
+
+  // Sends the png image to the layout test framework for comparison.
+  void SendPng() {
+    // Send image header & hash_ to the layout test framework.
+    printf("Content-Type: image/png\n");
+    printf("ActualHash: %s\n", base::MD5DigestToBase16(hash_).data());
+    printf("Content-Length: %" PRIuS "\n", output_.size());
+
+    for (size_t i = 0; i < output_.size(); ++i)
+      printf("%c", output_[i]);
+
+    printf("#EOF\n");
+    fflush(stdout);
+    fprintf(stderr, "#EOF\n");
+    fflush(stderr);
+  }
+
+  // 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(tab, browser()));
+    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 printing.
+  // Deletes the duplicate 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 the file that will be used for
+  // stdin to accept input. Also sets up the path to save the pdf file
+  // that will be printed. Everything is cleaned up automatically once
+  // the test ends.
+  void SetupStdinAndSavePath() {
+    // 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;
+    printf("#READY\n");
+    fflush(stdout);
+
+    ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
+    ASSERT_TRUE(base::CreateTemporaryFileInDir(tmp_dir_.path(), &tmp_path));
+    ASSERT_TRUE(freopen(tmp_path.value().c_str(), "r", stdin));
+
+    pdf_file_save_path_ = tmp_dir_.path().AppendASCII("dummy.pdf");
+
+    // Send the file path to the layout test framework so that it can
+    // communicate with this browsertest.
+    printf("StdinPath: %s\n#EOF\n", tmp_path.value().c_str());
+    fflush(stdout);
+  }
+
+ 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_input(bitmap_data.begin(), bitmap_data.end());
+    base::MD5Sum(static_cast<const void*>(hash_input.data()),
+                 hash_input.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.
+  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 library that contains the pdflib functions.
+  base::ScopedNativeLibrary pdf_lib_;
+
+  // Vector where the png is finally stored.
+  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 printf("#EOF\n") indicates that 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.
+  InitPdfFunctions();
+  SetupStdinAndSavePath();
+
+  // There is no way to determine how many tests are to be run
+  // ahead of time without a ton of modifications to the layout
+  // test framework. However, whenever it is done with a set of tests,
+  // it calls SIGKILL on the browser test that ran those set of tests.
+  // Thus, this while loop will end once the layout test framework
+  // decides to actually kill this process. For this to work,
+  // the test must be run with '--single_process'. There must be an
+  // underscore, not a dash, as that is something different.
+  while (true) {
+    base::FilePath::StringType cmd;
+    std::getline(STDIN_STREAM, cmd);
+    if (cmd.empty()) {
+      while (STDIN_STREAM.eof()) {
+        STDIN_STREAM.clear();
+        std::getline(STDIN_STREAM, cmd);
+        if (!cmd.empty()) {
+          break;
+        }
+      }
+    }
+
+    DuplicateTab();
+
+    // TODO(ivandavid): Get settings from file in resources.
+    PrintPreviewSettings settings(
+        true,
+        "",
+        false,
+        false,
+        printing::DEFAULT_MARGINS,
+        cmd.find(".pdf") != base::FilePath::StringType::npos);
+
+    // Splits the command sent by the layout test framework. The first
+    // 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);
+    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.
+    printf("#EOF\n");
+    fflush(stdout);
+
+    SendPng();
+    Reset();
+  }
+}