Home | History | Annotate | Download | only in printing 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <algorithm>
      6 #include <fstream>
      7 #include <iostream>
      8 #include <iterator>
      9 #include <limits>
     10 #include <string>
     11 #include <utility>
     12 #include <vector>
     13 
     14 #include "base/bind.h"
     15 #include "base/callback.h"
     16 #include "base/files/file.h"
     17 #include "base/files/file_path.h"
     18 #include "base/files/file_util.h"
     19 #include "base/files/scoped_temp_dir.h"
     20 #include "base/logging.h"
     21 #include "base/md5.h"
     22 #include "base/memory/scoped_ptr.h"
     23 #include "base/path_service.h"
     24 #include "base/run_loop.h"
     25 #include "base/scoped_native_library.h"
     26 #include "base/strings/string_split.h"
     27 #include "base/strings/utf_string_conversions.h"
     28 #include "chrome/browser/printing/print_preview_dialog_controller.h"
     29 #include "chrome/browser/ui/browser.h"
     30 #include "chrome/browser/ui/browser_commands.h"
     31 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     32 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
     33 #include "chrome/common/chrome_paths.h"
     34 #include "chrome/common/print_messages.h"
     35 #include "chrome/test/base/in_process_browser_test.h"
     36 #include "chrome/test/base/ui_test_utils.h"
     37 #include "content/public/browser/web_contents.h"
     38 #include "content/public/browser/web_ui_message_handler.h"
     39 #include "content/public/test/browser_test_utils.h"
     40 #include "ipc/ipc_message_macros.h"
     41 #include "net/base/filename_util.h"
     42 #include "printing/pdf_render_settings.h"
     43 #include "printing/units.h"
     44 #include "ui/gfx/codec/png_codec.h"
     45 #include "ui/gfx/geometry/rect.h"
     46 #include "url/gurl.h"
     47 
     48 #if defined(OS_WIN)
     49 #include <fcntl.h>
     50 #include <io.h>
     51 #endif
     52 
     53 using content::WebContents;
     54 using content::WebContentsObserver;
     55 
     56 namespace printing {
     57 
     58 // Number of color channels in a BGRA bitmap.
     59 const int kColorChannels = 4;
     60 const int kDpi = 300;
     61 
     62 // Every state is used when the document is a non-PDF source. When the source is
     63 // a PDF, kWaitingToSendSaveAsPDF, kWaitingToSendPageNumbers, and
     64 // kWaitingForFinalMessage are the only states used.
     65 enum State {
     66   // Waiting for the first message so the program can select Save as PDF
     67   kWaitingToSendSaveAsPdf = 0,
     68   // Waiting for the second message so the test can set the layout
     69   kWaitingToSendLayoutSettings = 1,
     70   // Waiting for the third message so the test can set the page numbers
     71   kWaitingToSendPageNumbers = 2,
     72   // Waiting for the forth message so the test can set the headers checkbox
     73   kWaitingToSendHeadersAndFooters = 3,
     74   // Waiting for the fifth message so the test can set the background checkbox
     75   kWaitingToSendBackgroundColorsAndImages = 4,
     76   // Waiting for the sixth message so the test can set the margins combobox
     77   kWaitingToSendMargins = 5,
     78   // Waiting for the final message so the program can save to PDF.
     79   kWaitingForFinalMessage = 6,
     80 };
     81 
     82 // Settings for print preview. It reflects the current options provided by
     83 // print preview. If more options are added, more states should be added and
     84 // there should be more settings added to this struct.
     85 struct PrintPreviewSettings {
     86   PrintPreviewSettings(bool is_portrait,
     87                        const std::string& page_numbers,
     88                        bool headers_and_footers,
     89                        bool background_colors_and_images,
     90                        MarginType margins,
     91                        bool source_is_pdf)
     92       : is_portrait(is_portrait),
     93         page_numbers(page_numbers),
     94         headers_and_footers(headers_and_footers),
     95         background_colors_and_images(background_colors_and_images),
     96         margins(margins),
     97         source_is_pdf(source_is_pdf) {}
     98 
     99   bool is_portrait;
    100   std::string page_numbers;
    101   bool headers_and_footers;
    102   bool background_colors_and_images;
    103   MarginType margins;
    104   bool source_is_pdf;
    105 };
    106 
    107 // Observes the print preview webpage. Once it observes the PreviewPageCount
    108 // message, will send a sequence of commands to the print preview dialog and
    109 // change the settings of the preview dialog.
    110 class PrintPreviewObserver : public WebContentsObserver {
    111  public:
    112   PrintPreviewObserver(Browser* browser,
    113                        WebContents* dialog,
    114                        const base::FilePath& pdf_file_save_path)
    115       : WebContentsObserver(dialog),
    116         browser_(browser),
    117         state_(kWaitingToSendSaveAsPdf),
    118         failed_setting_("None"),
    119         pdf_file_save_path_(pdf_file_save_path) {}
    120 
    121   virtual ~PrintPreviewObserver() {}
    122 
    123   // Sets closure for the observer so that it can end the loop.
    124   void set_quit_closure(const base::Closure &closure) {
    125     quit_closure_ = closure;
    126   }
    127 
    128   // Actually stops the message loop so that the test can proceed.
    129   void EndLoop() {
    130     base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
    131   }
    132 
    133   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
    134     IPC_BEGIN_MESSAGE_MAP(PrintPreviewObserver, message)
    135       IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPreviewPageCount,
    136                           OnDidGetPreviewPageCount)
    137     IPC_END_MESSAGE_MAP();
    138     return false;
    139   }
    140 
    141   // Gets the web contents for the print preview dialog so that the UI and
    142   // other elements can be accessed.
    143   WebContents* GetDialog() {
    144     WebContents* tab = browser_->tab_strip_model()->GetActiveWebContents();
    145     PrintPreviewDialogController* dialog_controller =
    146         PrintPreviewDialogController::GetInstance();
    147     return dialog_controller->GetPrintPreviewForContents(tab);
    148   }
    149 
    150   // Gets the PrintPreviewUI so that certain elements can be accessed.
    151   PrintPreviewUI* GetUI() {
    152     return static_cast<PrintPreviewUI*>(
    153         GetDialog()->GetWebUI()->GetController());
    154   }
    155 
    156   // Calls native_layer.onManipulateSettingsForTest() and sends a dictionary
    157   // value containing the type of setting and the value to set that settings
    158   // to.
    159   void ManipulatePreviewSettings() {
    160     base::DictionaryValue script_argument;
    161 
    162     if (state_ == kWaitingToSendSaveAsPdf) {
    163       script_argument.SetBoolean("selectSaveAsPdfDestination", true);
    164       state_ = settings_->source_is_pdf ?
    165                kWaitingToSendPageNumbers : kWaitingToSendLayoutSettings;
    166       failed_setting_ = "Save as PDF";
    167     } else if (state_ == kWaitingToSendLayoutSettings) {
    168       script_argument.SetBoolean("layoutSettings.portrait",
    169                                  settings_->is_portrait);
    170       state_ = kWaitingToSendPageNumbers;
    171       failed_setting_ = "Layout Settings";
    172     } else if (state_ == kWaitingToSendPageNumbers) {
    173       script_argument.SetString("pageRange", settings_->page_numbers);
    174       state_ = settings_->source_is_pdf ?
    175                kWaitingForFinalMessage : kWaitingToSendHeadersAndFooters;
    176       failed_setting_ = "Page Range";
    177     } else if (state_ == kWaitingToSendHeadersAndFooters) {
    178       script_argument.SetBoolean("headersAndFooters",
    179                                  settings_->headers_and_footers);
    180       state_ = kWaitingToSendBackgroundColorsAndImages;
    181       failed_setting_ = "Headers and Footers";
    182     } else if (state_ == kWaitingToSendBackgroundColorsAndImages) {
    183       script_argument.SetBoolean("backgroundColorsAndImages",
    184                                  settings_->background_colors_and_images);
    185       state_ = kWaitingToSendMargins;
    186       failed_setting_ = "Background Colors and Images";
    187     } else if (state_ == kWaitingToSendMargins) {
    188       script_argument.SetInteger("margins", settings_->margins);
    189       state_ = kWaitingForFinalMessage;
    190       failed_setting_ = "Margins";
    191     } else if (state_ == kWaitingForFinalMessage) {
    192       // Called by |GetUI()->handler_|, it is a callback function that call
    193       // |EndLoop| when an attempt to save the PDF has been made.
    194       base::Closure end_loop_closure =
    195           base::Bind(&PrintPreviewObserver::EndLoop, base::Unretained(this));
    196       GetUI()->SetPdfSavedClosureForTesting(end_loop_closure);
    197       ASSERT_FALSE(pdf_file_save_path_.empty());
    198       GetUI()->SetSelectedFileForTesting(pdf_file_save_path_);
    199       return;
    200     }
    201 
    202     ASSERT_FALSE(script_argument.empty());
    203     GetUI()->web_ui()->CallJavascriptFunction(
    204         "onManipulateSettingsForTest", script_argument);
    205   }
    206 
    207   // Saves the print preview settings to be sent to the print preview dialog.
    208   void SetPrintPreviewSettings(const PrintPreviewSettings& settings) {
    209     settings_.reset(new PrintPreviewSettings(settings));
    210   }
    211 
    212   // Returns the setting that could not be set in the preview dialog.
    213   const std::string& GetFailedSetting() const {
    214     return failed_setting_;
    215   }
    216 
    217  private:
    218   // Listens for messages from the print preview dialog. Specifically, it
    219   // listens for 'UILoadedForTest' and 'UIFailedLoadingForTest.'
    220   class UIDoneLoadingMessageHandler : public content::WebUIMessageHandler {
    221    public:
    222     explicit UIDoneLoadingMessageHandler(PrintPreviewObserver* observer)
    223         : observer_(observer) {}
    224 
    225     virtual ~UIDoneLoadingMessageHandler() {}
    226 
    227     // When a setting has been set succesfully, this is called and the observer
    228     // is told to send the next setting to be set.
    229     void HandleDone(const base::ListValue* /* args */) {
    230       observer_->ManipulatePreviewSettings();
    231     }
    232 
    233     // Ends the test because a setting was not set successfully. Called when
    234     // this class hears 'UIFailedLoadingForTest.'
    235     void HandleFailure(const base::ListValue* /* args */) {
    236       FAIL() << "Failed to set: " << observer_->GetFailedSetting();
    237     }
    238 
    239     // Allows this class to listen for the 'UILoadedForTest' and
    240     // 'UIFailedLoadingForTest' messages. These messages are sent by the print
    241     // preview dialog. 'UILoadedForTest' is sent when a setting has been
    242     // successfully set and its effects have been finalized.
    243     // 'UIFailedLoadingForTest' is sent when the setting could not be set. This
    244     // causes the browser test to fail.
    245     virtual void RegisterMessages() OVERRIDE {
    246       web_ui()->RegisterMessageCallback(
    247           "UILoadedForTest",
    248           base::Bind(&UIDoneLoadingMessageHandler::HandleDone,
    249                      base::Unretained(this)));
    250 
    251       web_ui()->RegisterMessageCallback(
    252           "UIFailedLoadingForTest",
    253           base::Bind(&UIDoneLoadingMessageHandler::HandleFailure,
    254                      base::Unretained(this)));
    255     }
    256 
    257    private:
    258     PrintPreviewObserver* const observer_;
    259 
    260     DISALLOW_COPY_AND_ASSIGN(UIDoneLoadingMessageHandler);
    261   };
    262 
    263   // Called when the observer gets the IPC message stating that the page count
    264   // is ready.
    265   void OnDidGetPreviewPageCount(
    266         const PrintHostMsg_DidGetPreviewPageCount_Params &params) {
    267     WebContents* web_contents = GetDialog();
    268     ASSERT_TRUE(web_contents);
    269     Observe(web_contents);
    270 
    271     PrintPreviewUI* ui = GetUI();
    272     ASSERT_TRUE(ui);
    273     ASSERT_TRUE(ui->web_ui());
    274 
    275     // The |ui->web_ui()| owns the message handler.
    276     ui->web_ui()->AddMessageHandler(new UIDoneLoadingMessageHandler(this));
    277     ui->web_ui()->CallJavascriptFunction("onEnableManipulateSettingsForTest");
    278   }
    279 
    280   virtual void DidCloneToNewWebContents(
    281       WebContents* old_web_contents,
    282       WebContents* new_web_contents) OVERRIDE {
    283     Observe(new_web_contents);
    284   }
    285 
    286   Browser* browser_;
    287   base::Closure quit_closure_;
    288   scoped_ptr<PrintPreviewSettings> settings_;
    289 
    290   // State of the observer. The state indicates what message to send
    291   // next. The state advances whenever the message handler calls
    292   // ManipulatePreviewSettings() on the observer.
    293   State state_;
    294   std::string failed_setting_;
    295   const base::FilePath pdf_file_save_path_;
    296 
    297   DISALLOW_COPY_AND_ASSIGN(PrintPreviewObserver);
    298 };
    299 
    300 class PrintPreviewPdfGeneratedBrowserTest : public InProcessBrowserTest {
    301  public:
    302   PrintPreviewPdfGeneratedBrowserTest() {}
    303   virtual ~PrintPreviewPdfGeneratedBrowserTest() {}
    304 
    305   // Navigates to the given web page, then initiates print preview and waits
    306   // for all the settings to be set, then save the preview to PDF.
    307   void NavigateAndPrint(const base::FilePath::StringType& file_name,
    308                           const PrintPreviewSettings& settings) {
    309     print_preview_observer_->SetPrintPreviewSettings(settings);
    310     base::FilePath path(file_name);
    311     GURL gurl = net::FilePathToFileURL(path);
    312 
    313     ui_test_utils::NavigateToURL(browser(), gurl);
    314 
    315     base::RunLoop loop;
    316     print_preview_observer_->set_quit_closure(loop.QuitClosure());
    317     chrome::Print(browser());
    318     loop.Run();
    319 
    320     // Need to check whether the save was successful. Ending the loop only
    321     // means the save was attempted.
    322     base::File pdf_file(
    323         pdf_file_save_path_, base::File::FLAG_OPEN | base::File::FLAG_READ);
    324     ASSERT_TRUE(pdf_file.IsValid());
    325   }
    326 
    327   // Initializes function pointers from the PDF library. Called once when the
    328   // test starts. The library is closed when the browser test ends.
    329   void InitPdfFunctions() {
    330     base::FilePath pdf_module_path;
    331 
    332     ASSERT_TRUE(PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path));
    333     ASSERT_TRUE(base::PathExists(pdf_module_path));
    334     pdf_lib_.Reset(base::LoadNativeLibrary(pdf_module_path, NULL));
    335 
    336     ASSERT_TRUE(pdf_lib_.is_valid());
    337     pdf_to_bitmap_func_ =
    338         reinterpret_cast<PDFPageToBitmapProc>(
    339             pdf_lib_.GetFunctionPointer("RenderPDFPageToBitmap"));
    340 
    341     pdf_doc_info_func_ =
    342         reinterpret_cast<GetPDFDocInfoProc>(
    343             pdf_lib_.GetFunctionPointer("GetPDFDocInfo"));
    344 
    345     pdf_page_size_func_ =
    346         reinterpret_cast<GetPDFPageSizeByIndexProc>(
    347             pdf_lib_.GetFunctionPointer("GetPDFPageSizeByIndex"));
    348 
    349     ASSERT_TRUE(pdf_to_bitmap_func_);
    350     ASSERT_TRUE(pdf_doc_info_func_);
    351     ASSERT_TRUE(pdf_page_size_func_);
    352   }
    353 
    354   // Converts the PDF to a PNG file so that the layout test can do an image
    355   // diff on this image and a reference image.
    356   void PdfToPng() {
    357     int num_pages;
    358     double max_width_in_points = 0;
    359     std::vector<uint8_t> bitmap_data;
    360     double total_height_in_pixels = 0;
    361     std::string pdf_data;
    362 
    363     ASSERT_TRUE(base::ReadFileToString(pdf_file_save_path_, &pdf_data));
    364     ASSERT_TRUE(pdf_doc_info_func_(pdf_data.data(),
    365                                    pdf_data.size(),
    366                                    &num_pages,
    367                                    &max_width_in_points));
    368 
    369     ASSERT_GT(num_pages, 0);
    370     double max_width_in_pixels =
    371         ConvertUnitDouble(max_width_in_points, kPointsPerInch, kDpi);
    372 
    373     for (int i = 0; i < num_pages; ++i) {
    374       double width_in_points, height_in_points;
    375       ASSERT_TRUE(pdf_page_size_func_(pdf_data.data(),
    376                                       pdf_data.size(),
    377                                       i,
    378                                       &width_in_points,
    379                                       &height_in_points));
    380 
    381       double width_in_pixels = ConvertUnitDouble(
    382           width_in_points, kPointsPerInch, kDpi);
    383       double height_in_pixels = ConvertUnitDouble(
    384           height_in_points, kPointsPerInch, kDpi);
    385 
    386       // The image will be rotated if |width_in_pixels| is greater than
    387       // |height_in_pixels|. This is because the page will be rotated to fit
    388       // within a piece of paper. Therefore, |width_in_pixels| and
    389       // |height_in_pixels| have to be swapped or else they won't reflect the
    390       // dimensions of the rotated page.
    391       if (width_in_pixels > height_in_pixels)
    392         std::swap(width_in_pixels, height_in_pixels);
    393 
    394       total_height_in_pixels += height_in_pixels;
    395       gfx::Rect rect(width_in_pixels, height_in_pixels);
    396       PdfRenderSettings settings(rect, kDpi, true);
    397 
    398       int int_max = std::numeric_limits<int>::max();
    399       if (settings.area().width() > int_max / kColorChannels ||
    400           settings.area().height() > int_max / (kColorChannels *
    401               settings.area().width())) {
    402         FAIL() << "The dimensions of the image are too large."
    403                << "Decrease the DPI or the dimensions of the image.";
    404       }
    405 
    406       std::vector<uint8_t> page_bitmap_data(
    407           kColorChannels * settings.area().size().GetArea());
    408 
    409       ASSERT_TRUE(pdf_to_bitmap_func_(pdf_data.data(),
    410                                       pdf_data.size(),
    411                                       i,
    412                                       page_bitmap_data.data(),
    413                                       settings.area().size().width(),
    414                                       settings.area().size().height(),
    415                                       settings.dpi(),
    416                                       settings.dpi(),
    417                                       true));
    418       FillPng(&page_bitmap_data,
    419               width_in_pixels,
    420               max_width_in_pixels,
    421               settings.area().size().height());
    422       bitmap_data.insert(bitmap_data.end(),
    423                          page_bitmap_data.begin(),
    424                          page_bitmap_data.end());
    425     }
    426 
    427     CreatePng(bitmap_data, max_width_in_pixels, total_height_in_pixels);
    428   }
    429 
    430   // Fills out a bitmap with whitespace so that the image will correctly fit
    431   // within a PNG that is wider than the bitmap itself.
    432   void FillPng(std::vector<uint8_t>* bitmap,
    433                int current_width,
    434                int desired_width,
    435                int height) {
    436     ASSERT_TRUE(bitmap);
    437     ASSERT_GT(height, 0);
    438     ASSERT_LE(current_width, desired_width);
    439 
    440     if (current_width == desired_width)
    441       return;
    442 
    443     int current_width_in_bytes = current_width * kColorChannels;
    444     int desired_width_in_bytes = desired_width * kColorChannels;
    445 
    446     // The color format is BGRA, so to set the color to white, every pixel is
    447     // set to 0xFFFFFFFF.
    448     const uint8_t kColorByte = 255;
    449     std::vector<uint8_t> filled_bitmap(
    450         desired_width * kColorChannels * height, kColorByte);
    451     std::vector<uint8_t>::iterator filled_bitmap_it = filled_bitmap.begin();
    452     std::vector<uint8_t>::iterator bitmap_it = bitmap->begin();
    453 
    454     for (int i = 0; i < height; ++i) {
    455       std::copy(
    456           bitmap_it, bitmap_it + current_width_in_bytes, filled_bitmap_it);
    457       std::advance(bitmap_it, current_width_in_bytes);
    458       std::advance(filled_bitmap_it, desired_width_in_bytes);
    459     }
    460 
    461     bitmap->assign(filled_bitmap.begin(), filled_bitmap.end());
    462   }
    463 
    464   // Sends the PNG image to the layout test framework for comparison.
    465   void SendPng() {
    466     // Send image header and |hash_| to the layout test framework.
    467     std::cout << "Content-Type: image/png\n";
    468     std::cout << "ActualHash: " << base::MD5DigestToBase16(hash_) << "\n";
    469     std::cout << "Content-Length: " << png_output_.size() << "\n";
    470 
    471     std::copy(png_output_.begin(),
    472               png_output_.end(),
    473               std::ostream_iterator<unsigned char>(std::cout, ""));
    474 
    475     std::cout << "#EOF\n";
    476     std::cout.flush();
    477     std::cerr << "#EOF\n";
    478     std::cerr.flush();
    479   }
    480 
    481   // Duplicates the tab that was created when the browser opened. This is done
    482   // so that the observer can listen to the duplicated tab as soon as possible
    483   // and start listening for messages related to print preview.
    484   void DuplicateTab() {
    485     WebContents* tab =
    486         browser()->tab_strip_model()->GetActiveWebContents();
    487     ASSERT_TRUE(tab);
    488 
    489     print_preview_observer_.reset(
    490         new PrintPreviewObserver(browser(), tab, pdf_file_save_path_));
    491     chrome::DuplicateTab(browser());
    492 
    493     WebContents* initiator =
    494         browser()->tab_strip_model()->GetActiveWebContents();
    495     ASSERT_TRUE(initiator);
    496     ASSERT_NE(tab, initiator);
    497   }
    498 
    499   // Resets the test so that another web page can be printed. It also deletes
    500   // the duplicated tab as it isn't needed anymore.
    501   void Reset() {
    502     png_output_.clear();
    503     ASSERT_EQ(2, browser()->tab_strip_model()->count());
    504     chrome::CloseTab(browser());
    505     ASSERT_EQ(1, browser()->tab_strip_model()->count());
    506   }
    507 
    508   // Creates a temporary directory to store a text file that will be used for
    509   // stdin to accept input from the layout test framework. A path for the PDF
    510   // file is also created. The directory and files within it are automatically
    511   // cleaned up once the test ends.
    512   void SetupStdinAndSavePath() {
    513     // Sets the filemode to binary because it will force |std::cout| to send LF
    514     // rather than CRLF. Sending CRLF will cause an error message for the
    515     // layout tests.
    516 #if defined(OS_WIN)
    517     _setmode(_fileno(stdout), _O_BINARY);
    518     _setmode(_fileno(stderr), _O_BINARY);
    519 #endif
    520     // Sends a message to the layout test framework indicating indicating
    521     // that the browser test has completed setting itself up. The layout
    522     // test will then expect the file path for stdin.
    523     base::FilePath stdin_path;
    524     std::cout << "#READY\n";
    525     std::cout.flush();
    526 
    527     ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
    528     ASSERT_TRUE(base::CreateTemporaryFileInDir(tmp_dir_.path(), &stdin_path));
    529 
    530     // Redirects |std::cin| to the file |stdin_path|. |in| is not freed because
    531     // if it goes out of scope, |std::cin.rdbuf| will be freed, causing an
    532     // error.
    533     std::ifstream* in = new std::ifstream(stdin_path.value().c_str());
    534     ASSERT_TRUE(in->is_open());
    535     std::cin.rdbuf(in->rdbuf());
    536 
    537     pdf_file_save_path_ =
    538         tmp_dir_.path().Append(FILE_PATH_LITERAL("dummy.pdf"));
    539 
    540     // Send the file path to the layout test framework so that it can
    541     // communicate with this browser test.
    542     std::cout << "StdinPath: " << stdin_path.value() << "\n";
    543     std::cout << "#EOF\n";
    544     std::cout.flush();
    545   }
    546 
    547  private:
    548   // Generates a png from bitmap data and stores it in |png_output_|.
    549   void CreatePng(const std::vector<uint8_t>& bitmap_data,
    550                  int width,
    551                  int height) {
    552     base::MD5Sum(static_cast<const void*>(bitmap_data.data()),
    553                  bitmap_data.size(),
    554                  &hash_);
    555     gfx::Rect png_rect(width, height);
    556 
    557     // tEXtchecksum looks funny, but that's what the layout test framework
    558     // expects.
    559     std::string comment_title("tEXtchecksum\x00");
    560     gfx::PNGCodec::Comment hash_comment(comment_title,
    561                                         base::MD5DigestToBase16(hash_));
    562     std::vector<gfx::PNGCodec::Comment> comments;
    563     comments.push_back(hash_comment);
    564     ASSERT_TRUE(gfx::PNGCodec::Encode(bitmap_data.data(),
    565                                       gfx::PNGCodec::FORMAT_BGRA,
    566                                       png_rect.size(),
    567                                       png_rect.size().width() * kColorChannels,
    568                                       false,
    569                                       comments,
    570                                       &png_output_));
    571   }
    572 
    573   scoped_ptr<PrintPreviewObserver> print_preview_observer_;
    574   base::FilePath pdf_file_save_path_;
    575 
    576   // These typedefs are function pointers to pdflib functions that give
    577   // information about the PDF as a whole and about specific pages.
    578 
    579   // Converts the PDF to a bitmap.
    580   typedef bool (*PDFPageToBitmapProc)(const void* pdf_buffer,
    581                                       int pdf_buffer_size,
    582                                       int page_number,
    583                                       void* bitmap_buffer,
    584                                       int bitmap_width,
    585                                       int bitmap_height,
    586                                       int dpi_x,
    587                                       int dpi_y,
    588                                       bool autorotate);
    589 
    590   // Gets the page count and maximum page width of the PDF in points.
    591   typedef bool (*GetPDFDocInfoProc)(const void* pdf_buffer,
    592                                     int buffer_size,
    593                                     int* pages_count,
    594                                     double* max_page_width);
    595 
    596   // Gets the dimensions of a specific page within a PDF.
    597   typedef bool (*GetPDFPageSizeByIndexProc)(const void* pdf_buffer,
    598                                             int buffer_size,
    599                                             int index,
    600                                             double* width,
    601                                             double* height);
    602 
    603   // Instantiations of the function pointers described above.
    604   PDFPageToBitmapProc pdf_to_bitmap_func_;
    605   GetPDFDocInfoProc pdf_doc_info_func_;
    606   GetPDFPageSizeByIndexProc pdf_page_size_func_;
    607 
    608   // Used to open up the pdf plugin, which contains the functions above.
    609   base::ScopedNativeLibrary pdf_lib_;
    610 
    611   // Vector for storing the PNG to be sent to the layout test framework.
    612   // TODO(ivandavid): Eventually change this to uint32_t and make everything
    613   // work with that. It might be a bit tricky to fix everything to work with
    614   // uint32_t, but not too tricky.
    615   std::vector<unsigned char> png_output_;
    616 
    617   // Image hash of the bitmap that is turned into a PNG. The hash is put into
    618   // the PNG as a comment, as it is needed by the layout test framework.
    619   base::MD5Digest hash_;
    620 
    621   // Temporary directory for storing the pdf and the file for stdin. It is
    622   // deleted by the layout tests.
    623   // TODO(ivandavid): Keep it as a ScopedTempDir and change the layout test
    624   // framework so that it tells the browser test how many test files there are.
    625   base::ScopedTempDir tmp_dir_;
    626 
    627   DISALLOW_COPY_AND_ASSIGN(PrintPreviewPdfGeneratedBrowserTest);
    628 };
    629 
    630 // This test acts as a driver for the layout test framework.
    631 IN_PROC_BROWSER_TEST_F(PrintPreviewPdfGeneratedBrowserTest,
    632                        MANUAL_LayoutTestDriver) {
    633   // What this code is supposed to do:
    634   // - Setup communication with the layout test framework
    635   // - Print webpage to a pdf
    636   // - Convert pdf to a png
    637   // - Send png to layout test framework, where it doesn an image diff
    638   //   on the image sent by this test and a reference image.
    639   //
    640   // Throughout this code, there will be |std::cout| statements. The layout test
    641   // framework uses stdout to get data from the browser test and uses stdin
    642   // to send data to the browser test. Writing "EOF\n" to |std::cout| indicates
    643   // that whatever block of data that the test was expecting has been completely
    644   // sent. Sometimes EOF is printed to stderr because the test will expect it
    645   // from stderr in addition to stdout for certain blocks of data.
    646   InitPdfFunctions();
    647   SetupStdinAndSavePath();
    648 
    649   while (true) {
    650     std::string input;
    651     while (input.empty()) {
    652       std::getline(std::cin, input);
    653       if (std::cin.eof())
    654         std::cin.clear();
    655     }
    656 
    657     // If the layout test framework sends "QUIT" to this test, that means there
    658     // are no more tests for this instance to run and it should quit.
    659     if (input == "QUIT")
    660       break;
    661 
    662     base::FilePath::StringType file_extension = FILE_PATH_LITERAL(".pdf");
    663     base::FilePath::StringType cmd;
    664 #if defined(OS_POSIX)
    665     cmd = input;
    666 #elif defined(OS_WIN)
    667     cmd = base::UTF8ToWide(input);
    668 #endif
    669 
    670     DuplicateTab();
    671     PrintPreviewSettings settings(
    672         true,
    673         "",
    674         false,
    675         false,
    676         DEFAULT_MARGINS,
    677         cmd.find(file_extension) != base::FilePath::StringType::npos);
    678 
    679     // Splits the command sent by the layout test framework. The first command
    680     // is always the file path to use for the test. The rest isn't relevant,
    681     // so it can be ignored. The separator for the commands is an apostrophe.
    682     std::vector<base::FilePath::StringType> cmd_arguments;
    683     base::SplitString(cmd, '\'', &cmd_arguments);
    684 
    685     ASSERT_GE(cmd_arguments.size(), 1U);
    686     base::FilePath::StringType test_name(cmd_arguments[0]);
    687     NavigateAndPrint(test_name, settings);
    688     PdfToPng();
    689 
    690     // Message to the layout test framework indicating that it should start
    691     // waiting for the image data, as there is no more text data to be read.
    692     // There actually isn't any text data at all, however because the layout
    693     // test framework requires it, a message has to be sent to stop it from
    694     // waiting for this message and start waiting for the image data.
    695     std::cout << "#EOF\n";
    696     std::cout.flush();
    697 
    698     SendPng();
    699     Reset();
    700   }
    701 }
    702 
    703 }  // namespace printing
    704