PrintPreview: Honor the print media page size and margin values.

chrome/renderer/mock_printer.cc

 // Copyright (c) 2011 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 "chrome/renderer/mock_printer.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/print_messages.h"
 #include "ipc/ipc_message_utils.h"
 #include "printing/metafile_impl.h"
 #include "printing/units.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+void UpdateMargins(int margins_type, int dpi, PrintMsg_Print_Params* params) {
+  if (margins_type == printing::NO_MARGINS) {
+    params->content_size.SetSize(static_cast<int>((8.5 * dpi)),
+                                 static_cast<int>((11.0 * dpi)));
+    params->margin_left = 0;
+    params->margin_top = 0;
+  } else if (margins_type == printing::PRINTABLE_AREA_MARGINS) {
+    params->content_size.SetSize(static_cast<int>((8.0 * dpi)),
+                                 static_cast<int>((10.5 * dpi)));
+    params->margin_left = static_cast<int>(0.25 * dpi);
+    params->margin_top = static_cast<int>(0.25 * dpi);
+  } else if (margins_type == printing::CUSTOM_MARGINS) {
+    params->content_size.SetSize(static_cast<int>((7.9 * dpi)),
+                                 static_cast<int>((10.4 * dpi)));
+    params->margin_left = static_cast<int>(0.30 * dpi);
+    params->margin_top = static_cast<int>(0.30 * dpi);
+  }
+}
+
+} // end
+
 MockPrinterPage::MockPrinterPage(const void* source_data,
                                  uint32 source_size,
                                  const printing::Image& image)
     : source_size_(source_size),
       image_(image) {
   // Create copies of the source data
   source_data_.reset(new uint8[source_size]);
   if (source_data_.get())
     memcpy(source_data_.get(), source_data, source_size);
 }
 
 MockPrinterPage::~MockPrinterPage() {}
 
 MockPrinter::MockPrinter()
   : dpi_(printing::kPointsPerInch),
     max_shrink_(2.0),
     min_shrink_(1.25),
     desired_dpi_(printing::kPointsPerInch),
     selection_only_(false),
     document_cookie_(-1),
     current_document_cookie_(0),
     printer_status_(PRINTER_READY),
     number_pages_(0),
     page_number_(0),
     is_first_request_(true),
+    print_to_pdf_(false),
     preview_request_id_(0),
     display_header_footer_(false),
     date_(ASCIIToUTF16("date")),
     title_(ASCIIToUTF16("title")),
     url_(ASCIIToUTF16("url")),
     use_invalid_settings_(false) {
   page_size_.SetSize(static_cast<int>(8.5 * dpi_),
                      static_cast<int>(11.0 * dpi_));
   content_size_.SetSize(static_cast<int>((7.5 * dpi_)),
                           static_cast<int>((10.0 * dpi_)));
   margin_left_ = margin_top_ = static_cast<int>(0.5 * dpi_);
+  printable_area_.SetRect(static_cast<int>(0.25 * dpi_),
+                          static_cast<int>(0.25 *dpi_),
+                          static_cast<int>(8 * dpi_),
+                          static_cast<int>(10.5 * dpi_));
 }
 
 MockPrinter::~MockPrinter() {
 }
 
 void MockPrinter::ResetPrinter() {
   printer_status_ = PRINTER_READY;
   document_cookie_ = -1;
 }
 
 void MockPrinter::GetDefaultPrintSettings(PrintMsg_Print_Params* params) {
   // Verify this printer is not processing a job.
   // Sorry, this mock printer is very fragile.
   EXPECT_EQ(-1, document_cookie_);
 
   // Assign a unit document cookie and set the print settings.
   document_cookie_ = CreateDocumentCookie();
   params->Reset();
   SetPrintParams(params);
 }
 
 void MockPrinter::SetDefaultPrintSettings(const PrintMsg_Print_Params& params) {
   dpi_ = params.dpi;
   max_shrink_ = params.max_shrink;
   min_shrink_ = params.min_shrink;
   desired_dpi_ = params.desired_dpi;
   selection_only_ = params.selection_only;
   page_size_ = params.page_size;
   content_size_ = params.content_size;
+  printable_area_ = params.printable_area;
   margin_left_ = params.margin_left;
   margin_top_ = params.margin_top;
   display_header_footer_ = params.display_header_footer;
   date_ = params.date;
   title_ = params.title;
   url_ = params.url;
 }
 
 void MockPrinter::UseInvalidSettings() {
   use_invalid_settings_ = true;
@@ skipping 11 matching lines @@
   settings->Reset();
 
   settings->params.dpi = dpi_;
   settings->params.max_shrink = max_shrink_;
   settings->params.min_shrink = min_shrink_;
   settings->params.desired_dpi = desired_dpi_;
   settings->params.selection_only = selection_only_;
   settings->params.document_cookie = document_cookie_;
   settings->params.page_size = page_size_;
   settings->params.content_size = content_size_;
+  settings->params.printable_area = printable_area_;
   settings->params.is_first_request = is_first_request_;
+  settings->params.print_to_pdf = print_to_pdf_;
   settings->params.preview_request_id = preview_request_id_;
   settings->params.display_header_footer = display_header_footer_;
   settings->params.date = date_;
   settings->params.title = title_;
   settings->params.url = url_;
   printer_status_ = PRINTER_PRINTING;
 }
 
 void MockPrinter::UpdateSettings(int cookie,
                                  PrintMsg_PrintPages_Params* params,
-                                 const std::vector<int>& pages) {
+                                 const std::vector<int>& pages,
+                                 int margins_type) {
   if (document_cookie_ == -1) {
     document_cookie_ = CreateDocumentCookie();
   }
   params->Reset();
   params->pages = pages;
   SetPrintParams(&(params->params));
+  UpdateMargins(margins_type, dpi_, &(params->params));
   printer_status_ = PRINTER_PRINTING;
 }
 
 void MockPrinter::SetPrintedPagesCount(int cookie, int number_pages) {
   // Verify the input parameter and update the printer status so that the
   // RenderViewTest class can verify the this function finishes without errors.
   EXPECT_EQ(document_cookie_, cookie);
   EXPECT_EQ(PRINTER_PRINTING, printer_status_);
   EXPECT_EQ(0, number_pages_);
   EXPECT_EQ(0, page_number_);
@@ skipping 109 matching lines @@
 
 void MockPrinter::SetPrintParams(PrintMsg_Print_Params* params) {
   params->dpi = dpi_;
   params->max_shrink = max_shrink_;
   params->min_shrink = min_shrink_;
   params->desired_dpi = desired_dpi_;
   params->selection_only = selection_only_;
   params->document_cookie = document_cookie_;
   params->page_size = page_size_;
   params->content_size = content_size_;
+  params->printable_area = printable_area_;
   params->margin_left = margin_left_;
   params->margin_top = margin_top_;
   params->is_first_request = is_first_request_;
+  params->print_to_pdf = print_to_pdf_;
   params->preview_request_id = preview_request_id_;
   params->display_header_footer = display_header_footer_;
   params->date = date_;
   params->title = title_;
   params->url = url_;
 }