Patch up excessive margins until we can get the real fix plumbed through.

chrome/renderer/print_web_view_helper.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/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 125 matching lines @@
 void CalculatePrintCanvasSize(const PrintMsg_Print_Params& print_params,
                               gfx::Size* result) {
   int dpi = GetDPI(&print_params);
   result->set_width(ConvertUnit(print_params.printable_size.width(), dpi,
                                 print_params.desired_dpi));
 
   result->set_height(ConvertUnit(print_params.printable_size.height(), dpi,
                                  print_params.desired_dpi));
 }
 
+bool PrintingNodeOrPdfFrame(const WebFrame* frame, const WebNode& node) {
+  if (!node.isNull())
+    return true;
+  std::string mime(frame->dataSource()->response().mimeType().utf8());
+  return mime == "application/pdf";
+}
+
+void SetMarginsForPDF(PrintMsg_Print_Params* settings) {
+  // This is the wrong way to do this.  But the pipeline for the right way is
+  // too long.  This will be removed soon. http://crbug.com/92000
+  settings->margin_top = 0;
+  settings->margin_left = 0;
+  settings->printable_size.set_width(settings->page_size.width());
+  settings->printable_size.set_height(settings->page_size.height());
+}
+
 // Get the margins option selected and set custom margins appropriately.
 void SetCustomMarginsIfSelected(const DictionaryValue& job_settings,
                                 PrintMsg_PrintPages_Params* settings) {
   bool default_margins_selected;
   if (!job_settings.GetBoolean(printing::kSettingDefaultMarginsSelected,
                                &default_margins_selected)) {
     NOTREACHED();
     default_margins_selected = true;
   }
 
@@ skipping 845 matching lines @@
     page_layout_in_points->margin_left =
         ConvertPixelsToPointDouble(margin_left_in_pixels);
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::UpdatePrintableSizeInPrintParameters(
     WebFrame* frame,
     const WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
     PrintMsg_Print_Params* params) {
+  if (PrintingNodeOrPdfFrame(frame, node))
+    return;
   PageSizeMargins page_layout_in_points;
   PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, *params,
                                                     &page_layout_in_points);
   int dpi = GetDPI(params);
   params->printable_size = gfx::Size(
       static_cast<int>(ConvertUnitDouble(
           page_layout_in_points.content_width,
           printing::kPointsPerInch, dpi)),
       static_cast<int>(ConvertUnitDouble(
           page_layout_in_points.content_height,
@@ skipping 63 matching lines @@
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
   UpdatePrintableSizeInPrintParameters(frame, node, prepare->get(),
                                        &print_pages_params_->params);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
-    const DictionaryValue& job_settings, bool is_preview) {
+    const DictionaryValue& job_settings, bool generating_preview) {
   if (job_settings.empty()) {
-    if (is_preview)
+    if (generating_preview)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
   // Send the cookie so that UpdatePrintSettings can reuse PrinterQuery when
   // possible.
   int cookie = print_pages_params_.get() ?
       print_pages_params_->params.document_cookie : 0;
   PrintMsg_PrintPages_Params settings;
   Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
       cookie, job_settings, &settings));
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
 
   if (PrintMsg_Print_Params_IsEmpty(settings.params)) {
-    if (is_preview) {
+    if (generating_preview) {
       print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
     } else {
       WebKit::WebFrame* frame = print_preview_context_.frame();
       if (!frame) {
         GetPrintFrame(&frame);
       }
       if (frame) {
         render_view()->runModalAlertDialog(
             frame,
             l10n_util::GetStringUTF16(
                 IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
       }
     }
     return false;
   }
 
   if (settings.params.dpi < kMinDpi || !settings.params.document_cookie) {
     print_preview_context_.set_error(PREVIEW_ERROR_UPDATING_PRINT_SETTINGS);
     return false;
   }
 
-  if (is_preview) {
+  if (generating_preview) {
     // Validate expected print preview settings.
     if (!job_settings.GetString(printing::kPreviewUIAddr,
                                 &(settings.params.preview_ui_addr)) ||
         !job_settings.GetInteger(printing::kPreviewRequestID,
                                  &(settings.params.preview_request_id)) ||
         !job_settings.GetBoolean(printing::kIsFirstRequest,
                                  &(settings.params.is_first_request))) {
       NOTREACHED();
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
       return false;
@@ skipping 20 matching lines @@
       header_footer_info_.reset(new DictionaryValue());
       header_footer_info_->SetString(printing::kSettingHeaderFooterDate,
                                      settings.params.date);
       header_footer_info_->SetString(printing::kSettingHeaderFooterURL,
                                      settings.params.url);
       header_footer_info_->SetString(printing::kSettingHeaderFooterTitle,
                                      settings.params.title);
     }
   }
 
+  if ((is_preview_ && !generating_preview) ||
+      PrintingNodeOrPdfFrame(print_preview_context_.frame(),
+                             print_preview_context_.node())) {
+    SetMarginsForPDF(&settings.params);
+  }
+
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::GetPrintSettingsFromUser(WebKit::WebFrame* frame,
                                                   int expected_pages_count,
                                                   bool use_browser_overlays) {
   PrintHostMsg_ScriptedPrint_Params params;
@@ skipping 314 matching lines @@
   if (IsFinalPageRendered())
     return -1;
   return pages_to_render_[current_page_index_++];
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsReadyToRender() const {
   return state_ != UNINITIALIZED;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
-  // TODO(vandebo) I think this should only return false if the content is a
-  // PDF, just because we are printing a particular node does not mean it's
-  // a PDF (right?), we should check the mime type of the node.
-  if (!node().isNull())
-    return false;
-  std::string mime(frame()->dataSource()->response().mimeType().utf8());
-  return mime != "application/pdf";
+  // The only kind of node we can print right now is a PDF node.
+  return !PrintingNodeOrPdfFrame(frame(), node());
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
     const {
   return current_page_index_ == print_ready_metafile_page_count_;
 }
 
 bool  PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
   return static_cast<size_t>(current_page_index_) == pages_to_render_.size();
 }
@@ skipping 43 matching lines @@
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }