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 "chrome/renderer/printing/mock_printer.h"
6
7#include "base/basictypes.h"
8#include "base/files/file_util.h"
9#include "base/memory/shared_memory.h"
10#include "base/strings/string16.h"
11#include "base/strings/utf_string_conversions.h"
12#include "chrome/common/print_messages.h"
13#include "ipc/ipc_message_utils.h"
14#include "printing/pdf_metafile_skia.h"
15#include "printing/units.h"
16#include "testing/gtest/include/gtest/gtest.h"
17
18#if defined(OS_MACOSX)
19#include "printing/pdf_metafile_cg_mac.h"
20#endif
21
22namespace {
23
24void UpdateMargins(int margins_type, int dpi, PrintMsg_Print_Params* params) {
25  if (margins_type == printing::NO_MARGINS) {
26    params->content_size.SetSize(static_cast<int>((8.5 * dpi)),
27                                 static_cast<int>((11.0 * dpi)));
28    params->margin_left = 0;
29    params->margin_top = 0;
30  } else if (margins_type == printing::PRINTABLE_AREA_MARGINS) {
31    params->content_size.SetSize(static_cast<int>((8.0 * dpi)),
32                                 static_cast<int>((10.5 * dpi)));
33    params->margin_left = static_cast<int>(0.25 * dpi);
34    params->margin_top = static_cast<int>(0.25 * dpi);
35  } else if (margins_type == printing::CUSTOM_MARGINS) {
36    params->content_size.SetSize(static_cast<int>((7.9 * dpi)),
37                                 static_cast<int>((10.4 * dpi)));
38    params->margin_left = static_cast<int>(0.30 * dpi);
39    params->margin_top = static_cast<int>(0.30 * dpi);
40  }
41}
42
43}  // namespace
44
45MockPrinterPage::MockPrinterPage(const void* source_data,
46                                 uint32 source_size,
47                                 const printing::Image& image)
48    : source_size_(source_size),
49      image_(image) {
50  // Create copies of the source data
51  source_data_.reset(new uint8[source_size]);
52  if (source_data_.get())
53    memcpy(source_data_.get(), source_data, source_size);
54}
55
56MockPrinterPage::~MockPrinterPage() {}
57
58MockPrinter::MockPrinter()
59  : dpi_(printing::kPointsPerInch),
60    max_shrink_(2.0),
61    min_shrink_(1.25),
62    desired_dpi_(printing::kPointsPerInch),
63    selection_only_(false),
64    should_print_backgrounds_(false),
65    document_cookie_(-1),
66    current_document_cookie_(0),
67    printer_status_(PRINTER_READY),
68    number_pages_(0),
69    page_number_(0),
70    is_first_request_(true),
71    print_to_pdf_(false),
72    preview_request_id_(0),
73    print_scaling_option_(blink::WebPrintScalingOptionSourceSize),
74    display_header_footer_(false),
75    title_(base::ASCIIToUTF16("title")),
76    url_(base::ASCIIToUTF16("url")),
77    use_invalid_settings_(false) {
78  page_size_.SetSize(static_cast<int>(8.5 * dpi_),
79                     static_cast<int>(11.0 * dpi_));
80  content_size_.SetSize(static_cast<int>((7.5 * dpi_)),
81                          static_cast<int>((10.0 * dpi_)));
82  margin_left_ = margin_top_ = static_cast<int>(0.5 * dpi_);
83  printable_area_.SetRect(static_cast<int>(0.25 * dpi_),
84                          static_cast<int>(0.25 *dpi_),
85                          static_cast<int>(8 * dpi_),
86                          static_cast<int>(10.5 * dpi_));
87}
88
89MockPrinter::~MockPrinter() {
90}
91
92void MockPrinter::ResetPrinter() {
93  printer_status_ = PRINTER_READY;
94  document_cookie_ = -1;
95}
96
97void MockPrinter::GetDefaultPrintSettings(PrintMsg_Print_Params* params) {
98  // Verify this printer is not processing a job.
99  // Sorry, this mock printer is very fragile.
100  EXPECT_EQ(-1, document_cookie_);
101
102  // Assign a unit document cookie and set the print settings.
103  document_cookie_ = CreateDocumentCookie();
104  params->Reset();
105  SetPrintParams(params);
106}
107
108void MockPrinter::SetDefaultPrintSettings(const PrintMsg_Print_Params& params) {
109  dpi_ = params.dpi;
110  max_shrink_ = params.max_shrink;
111  min_shrink_ = params.min_shrink;
112  desired_dpi_ = params.desired_dpi;
113  selection_only_ = params.selection_only;
114  should_print_backgrounds_ = params.should_print_backgrounds;
115  page_size_ = params.page_size;
116  content_size_ = params.content_size;
117  printable_area_ = params.printable_area;
118  margin_left_ = params.margin_left;
119  margin_top_ = params.margin_top;
120  display_header_footer_ = params.display_header_footer;
121  title_ = params.title;
122  url_ = params.url;
123}
124
125void MockPrinter::UseInvalidSettings() {
126  use_invalid_settings_ = true;
127  PrintMsg_Print_Params empty_param;
128  SetDefaultPrintSettings(empty_param);
129}
130
131void MockPrinter::UseInvalidPageSize() {
132  page_size_.SetSize(0, 0);
133}
134
135void MockPrinter::UseInvalidContentSize() {
136  content_size_.SetSize(0, 0);
137}
138
139void MockPrinter::ScriptedPrint(int cookie,
140                                int expected_pages_count,
141                                bool has_selection,
142                                PrintMsg_PrintPages_Params* settings) {
143  // Verify the input parameters.
144  EXPECT_EQ(document_cookie_, cookie);
145
146  settings->Reset();
147
148  settings->params.dpi = dpi_;
149  settings->params.max_shrink = max_shrink_;
150  settings->params.min_shrink = min_shrink_;
151  settings->params.desired_dpi = desired_dpi_;
152  settings->params.selection_only = selection_only_;
153  settings->params.should_print_backgrounds = should_print_backgrounds_;
154  settings->params.document_cookie = document_cookie_;
155  settings->params.page_size = page_size_;
156  settings->params.content_size = content_size_;
157  settings->params.printable_area = printable_area_;
158  settings->params.is_first_request = is_first_request_;
159  settings->params.print_scaling_option = print_scaling_option_;
160  settings->params.print_to_pdf = print_to_pdf_;
161  settings->params.preview_request_id = preview_request_id_;
162  settings->params.display_header_footer = display_header_footer_;
163  settings->params.title = title_;
164  settings->params.url = url_;
165  printer_status_ = PRINTER_PRINTING;
166}
167
168void MockPrinter::UpdateSettings(int cookie,
169                                 PrintMsg_PrintPages_Params* params,
170                                 const std::vector<int>& pages,
171                                 int margins_type) {
172  if (document_cookie_ == -1) {
173    document_cookie_ = CreateDocumentCookie();
174  }
175  params->Reset();
176  params->pages = pages;
177  SetPrintParams(&(params->params));
178  UpdateMargins(margins_type, dpi_, &(params->params));
179  printer_status_ = PRINTER_PRINTING;
180}
181
182void MockPrinter::SetPrintedPagesCount(int cookie, int number_pages) {
183  // Verify the input parameter and update the printer status so that the
184  // RenderViewTest class can verify the this function finishes without errors.
185  EXPECT_EQ(document_cookie_, cookie);
186  EXPECT_EQ(PRINTER_PRINTING, printer_status_);
187  EXPECT_EQ(0, number_pages_);
188  EXPECT_EQ(0, page_number_);
189
190  // Initialize the job status.
191  number_pages_ = number_pages;
192  page_number_ = 0;
193  pages_.clear();
194}
195
196void MockPrinter::PrintPage(const PrintHostMsg_DidPrintPage_Params& params) {
197  // Verify the input parameter and update the printer status so that the
198  // RenderViewTest class can verify the this function finishes without errors.
199  EXPECT_EQ(PRINTER_PRINTING, printer_status_);
200  EXPECT_EQ(document_cookie_, params.document_cookie);
201  EXPECT_EQ(page_number_, params.page_number);
202  EXPECT_LE(params.page_number, number_pages_);
203
204#if defined(OS_WIN) || defined(OS_MACOSX)
205  // Load the data sent from a RenderView object and create a PageData object.
206  // We duplicate the given file handle when creating a base::SharedMemory
207  // instance so that its destructor closes the copy.
208  EXPECT_GT(params.data_size, 0U);
209#if defined(OS_WIN)
210  base::SharedMemory metafile_data(params.metafile_data_handle, true,
211                                   GetCurrentProcess());
212#elif defined(OS_MACOSX)
213  base::SharedMemory metafile_data(params.metafile_data_handle, true);
214#endif
215  metafile_data.Map(params.data_size);
216#if defined(OS_MACOSX)
217  printing::PdfMetafileCg metafile;
218#else
219  printing::PdfMetafileSkia metafile;
220#endif
221  metafile.InitFromData(metafile_data.memory(), params.data_size);
222  printing::Image image(metafile);
223  MockPrinterPage* page_data = new MockPrinterPage(metafile_data.memory(),
224                                                   params.data_size,
225                                                   image);
226  scoped_refptr<MockPrinterPage> page(page_data);
227  pages_.push_back(page);
228#endif
229
230  // We finish printing a printing job.
231  // Reset the job status and the printer status.
232  ++page_number_;
233  if (number_pages_ == page_number_)
234    ResetPrinter();
235}
236
237int MockPrinter::GetPrintedPages() const {
238  if (printer_status_ != PRINTER_READY)
239    return -1;
240  return page_number_;
241}
242
243const MockPrinterPage* MockPrinter::GetPrintedPage(unsigned int pageno) const {
244  if (pages_.size() > pageno)
245    return pages_[pageno].get();
246  else
247    return NULL;
248}
249
250int MockPrinter::GetWidth(unsigned int page) const {
251  if (printer_status_ != PRINTER_READY || page >= pages_.size())
252    return -1;
253  return pages_[page]->width();
254}
255
256int MockPrinter::GetHeight(unsigned int page) const {
257  if (printer_status_ != PRINTER_READY || page >= pages_.size())
258    return -1;
259  return pages_[page]->height();
260}
261
262bool MockPrinter::GetBitmapChecksum(
263    unsigned int page, std::string* checksum) const {
264  if (printer_status_ != PRINTER_READY || page >= pages_.size())
265    return false;
266  *checksum = pages_[page]->image().checksum();
267  return true;
268}
269
270bool MockPrinter::SaveSource(
271    unsigned int page, const base::FilePath& filepath) const {
272  if (printer_status_ != PRINTER_READY || page >= pages_.size())
273    return false;
274  const uint8* source_data = pages_[page]->source_data();
275  uint32 source_size = pages_[page]->source_size();
276  base::WriteFile(filepath, reinterpret_cast<const char*>(source_data),
277                  source_size);
278  return true;
279}
280
281bool MockPrinter::SaveBitmap(
282    unsigned int page, const base::FilePath& filepath) const {
283  if (printer_status_ != PRINTER_READY || page >= pages_.size())
284    return false;
285
286  pages_[page]->image().SaveToPng(filepath);
287  return true;
288}
289
290int MockPrinter::CreateDocumentCookie() {
291  return use_invalid_settings_ ? 0 : ++current_document_cookie_;
292}
293
294void MockPrinter::SetPrintParams(PrintMsg_Print_Params* params) {
295  params->dpi = dpi_;
296  params->max_shrink = max_shrink_;
297  params->min_shrink = min_shrink_;
298  params->desired_dpi = desired_dpi_;
299  params->selection_only = selection_only_;
300  params->should_print_backgrounds = should_print_backgrounds_;
301  params->document_cookie = document_cookie_;
302  params->page_size = page_size_;
303  params->content_size = content_size_;
304  params->printable_area = printable_area_;
305  params->margin_left = margin_left_;
306  params->margin_top = margin_top_;
307  params->is_first_request = is_first_request_;
308  params->print_scaling_option = print_scaling_option_;
309  params->print_to_pdf = print_to_pdf_;
310  params->preview_request_id = preview_request_id_;
311  params->display_header_footer = display_header_footer_;
312  params->title = title_;
313  params->url = url_;
314}
315