"Using" cleanup.

chrome/renderer/print_web_view_helper.cc

 // Copyright (c) 2012 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/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 42 matching lines @@
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #define USE_RENDER_TEXT
 #endif
 
 #if defined(USE_RENDER_TEXT)
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/render_text.h"
 #endif
 
-using printing::ConvertPixelsToPoint;
-using printing::ConvertPixelsToPointDouble;
-using printing::ConvertPointsToPixelDouble;
-using printing::ConvertUnit;
-using printing::ConvertUnitDouble;
-using printing::GetHeaderFooterSegmentWidth;
-using printing::PageSizeMargins;
-using WebKit::WebConsoleMessage;
-using WebKit::WebDocument;
-using WebKit::WebElement;
-using WebKit::WebFrame;
-using WebKit::WebNode;
-using WebKit::WebPlugin;
-using WebKit::WebPluginDocument;
-using WebKit::WebPrintParams;
-using WebKit::WebSize;
-using WebKit::WebString;
-using WebKit::WebURLRequest;
-using WebKit::WebView;
-
 namespace {
 
 #if defined(USE_RENDER_TEXT)
 typedef gfx::RenderText* HeaderFooterPaint;
 #else
 typedef SkPaint HeaderFooterPaint;
 #endif
 
 const double kMinDpi = 1.0;
 
@@ skipping 41 matching lines @@
          oldParams.params.display_header_footer ==
              newParams.params.display_header_footer &&
          oldParams.params.date == newParams.params.date &&
          oldParams.params.title == newParams.params.title &&
          oldParams.params.url == newParams.params.url &&
          std::equal(oldParams.pages.begin(), oldParams.pages.end(),
              newParams.pages.begin());
 }
 
 PrintMsg_Print_Params GetCssPrintParams(
-    WebFrame* frame,
+    WebKit::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params) {
   PrintMsg_Print_Params page_css_params = page_params;
   int dpi = GetDPI(&page_params);
-  WebSize page_size_in_pixels(
-      ConvertUnit(page_params.page_size.width(),
-                  dpi, printing::kPixelsPerInch),
-      ConvertUnit(page_params.page_size.height(),
-                  dpi, printing::kPixelsPerInch));
-  int margin_top_in_pixels = ConvertUnit(
-      page_params.margin_top,
-      dpi, printing::kPixelsPerInch);
+
+  using printing::ConvertUnit;
+  using printing::kPixelsPerInch;
+  WebKit::WebSize page_size_in_pixels(
+      ConvertUnit(page_params.page_size.width(), dpi, kPixelsPerInch),
+      ConvertUnit(page_params.page_size.height(), dpi, kPixelsPerInch));
+  int margin_top_in_pixels =
+      ConvertUnit(page_params.margin_top, dpi, kPixelsPerInch);
   int margin_right_in_pixels = ConvertUnit(
       page_params.page_size.width() -
       page_params.content_size.width() - page_params.margin_left,
-      dpi, printing::kPixelsPerInch);
+      dpi, kPixelsPerInch);
   int margin_bottom_in_pixels = ConvertUnit(
       page_params.page_size.height() -
       page_params.content_size.height() - page_params.margin_top,
-      dpi, printing::kPixelsPerInch);
+      dpi, kPixelsPerInch);
   int margin_left_in_pixels = ConvertUnit(
       page_params.margin_left,
-      dpi, printing::kPixelsPerInch);
+      dpi, kPixelsPerInch);
 
-  WebSize original_page_size_in_pixels = page_size_in_pixels;
+  WebKit::WebSize original_page_size_in_pixels = page_size_in_pixels;
 
   if (frame) {
     frame->pageSizeAndMarginsInPixels(page_index,
                                       page_size_in_pixels,
                                       margin_top_in_pixels,
                                       margin_right_in_pixels,
                                       margin_bottom_in_pixels,
                                       margin_left_in_pixels);
   }
 
   int new_content_width = page_size_in_pixels.width -
                           margin_left_in_pixels - margin_right_in_pixels;
   int new_content_height = page_size_in_pixels.height -
                            margin_top_in_pixels - margin_bottom_in_pixels;
 
   // Invalid page size and/or margins. We just use the default setting.
   if (new_content_width < 1 || new_content_height < 1) {
     CHECK(frame != NULL);
     page_css_params = GetCssPrintParams(NULL, page_index, page_params);
     return page_css_params;
   }
 
   page_css_params.content_size = gfx::Size(
-      static_cast<int>(ConvertUnit(new_content_width,
-          printing::kPixelsPerInch, dpi)),
-      static_cast<int>(ConvertUnit(new_content_height,
-          printing::kPixelsPerInch, dpi)));
+      ConvertUnit(new_content_width, kPixelsPerInch, dpi),
+      ConvertUnit(new_content_height, kPixelsPerInch, dpi));
 
   if (original_page_size_in_pixels != page_size_in_pixels) {
     page_css_params.page_size = gfx::Size(
-        static_cast<int>(ConvertUnit(page_size_in_pixels.width,
-            printing::kPixelsPerInch, dpi)),
-        static_cast<int>(ConvertUnit(page_size_in_pixels.height,
-            printing::kPixelsPerInch, dpi)));
+        ConvertUnit(page_size_in_pixels.width, kPixelsPerInch, dpi),
+        ConvertUnit(page_size_in_pixels.height, kPixelsPerInch, dpi));
   } else {
     // Printing frame doesn't have any page size css. Pixels to dpi conversion
     // causes rounding off errors. Therefore use the default page size values
     // directly.
     page_css_params.page_size = page_params.page_size;
   }
 
   page_css_params.margin_top =
-      static_cast<int>(ConvertUnit(margin_top_in_pixels,
-          printing::kPixelsPerInch, dpi));
-
+      ConvertUnit(margin_top_in_pixels, kPixelsPerInch, dpi);
   page_css_params.margin_left =
-      static_cast<int>(ConvertUnit(margin_left_in_pixels,
-          printing::kPixelsPerInch, dpi));
+      ConvertUnit(margin_left_in_pixels, kPixelsPerInch, dpi);
   return page_css_params;
 }
 
 double FitPrintParamsToPage(const PrintMsg_Print_Params& page_params,
                             PrintMsg_Print_Params* params_to_fit) {
   double content_width =
       static_cast<double>(params_to_fit->content_size.width());
   double content_height =
       static_cast<double>(params_to_fit->content_size.height());
   int default_page_size_height = page_params.page_size.height();
@@ skipping 22 matching lines @@
       (default_page_size_width - css_page_size_width * scale_factor) / 2 +
       (params_to_fit->margin_left * scale_factor));
   params_to_fit->content_size = gfx::Size(
       static_cast<int>(content_width), static_cast<int>(content_height));
   params_to_fit->page_size = page_params.page_size;
   return scale_factor;
 }
 
 void CalculatePageLayoutFromPrintParams(
     const PrintMsg_Print_Params& params,
-    PageSizeMargins* page_layout_in_points) {
+    printing::PageSizeMargins* page_layout_in_points) {
   int dpi = GetDPI(&params);
   int content_width = params.content_size.width();
   int content_height = params.content_size.height();
 
   int margin_bottom = params.page_size.height() -
                       content_height - params.margin_top;
   int margin_right = params.page_size.width() -
                       content_width - params.margin_left;
 
-  page_layout_in_points->content_width = ConvertUnit(
-      content_width, dpi, printing::kPointsPerInch);
-  page_layout_in_points->content_height = ConvertUnit(
-      content_height, dpi, printing::kPointsPerInch);
-  page_layout_in_points->margin_top = ConvertUnit(
-      params.margin_top, dpi, printing::kPointsPerInch);
-  page_layout_in_points->margin_right = ConvertUnit(
-      margin_right, dpi, printing::kPointsPerInch);
-  page_layout_in_points->margin_bottom = ConvertUnit(
-      margin_bottom, dpi, printing::kPointsPerInch);
-  page_layout_in_points->margin_left = ConvertUnit(
-      params.margin_left, dpi, printing::kPointsPerInch);
+  using printing::ConvertUnit;
+  using printing::kPointsPerInch;
+  page_layout_in_points->content_width =
+      ConvertUnit(content_width, dpi, kPointsPerInch);
+  page_layout_in_points->content_height =
+      ConvertUnit(content_height, dpi, kPointsPerInch);
+  page_layout_in_points->margin_top =
+      ConvertUnit(params.margin_top, dpi, kPointsPerInch);
+  page_layout_in_points->margin_right =
+      ConvertUnit(margin_right, dpi, kPointsPerInch);
+  page_layout_in_points->margin_bottom =
+      ConvertUnit(margin_bottom, dpi, kPointsPerInch);
+  page_layout_in_points->margin_left =
+      ConvertUnit(params.margin_left, dpi, kPointsPerInch);
 }
 
 void EnsureOrientationMatches(const PrintMsg_Print_Params& css_params,
                               PrintMsg_Print_Params* page_params) {
   if ((page_params->page_size.width() > page_params->page_size.height()) ==
       (css_params.page_size.width() > css_params.page_size.height())) {
     return;
   }
 
   // Swap the |width| and |height| values.
   page_params->page_size.SetSize(page_params->page_size.height(),
                                  page_params->page_size.width());
   page_params->content_size.SetSize(page_params->content_size.height(),
                                     page_params->content_size.width());
   page_params->printable_area.set_size(
       gfx::Size(page_params->printable_area.height(),
                 page_params->printable_area.width()));
 }
 
 void ComputeWebKitPrintParamsInDesiredDpi(
     const PrintMsg_Print_Params& print_params,
-    WebPrintParams* webkit_print_params) {
+    WebKit::WebPrintParams* webkit_print_params) {
   int dpi = GetDPI(&print_params);
   webkit_print_params->printerDPI = dpi;
   webkit_print_params->printScalingOption = print_params.print_scaling_option;
 
+  using printing::ConvertUnit;
   webkit_print_params->printContentArea.width =
       ConvertUnit(print_params.content_size.width(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->printContentArea.height =
       ConvertUnit(print_params.content_size.height(), dpi,
                   print_params.desired_dpi);
 
   webkit_print_params->printableArea.x =
       ConvertUnit(print_params.printable_area.x(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->printableArea.y =
       ConvertUnit(print_params.printable_area.y(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->printableArea.width =
       ConvertUnit(print_params.printable_area.width(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->printableArea.height =
       ConvertUnit(print_params.printable_area.height(),
                   dpi, print_params.desired_dpi);
 
   webkit_print_params->paperSize.width =
       ConvertUnit(print_params.page_size.width(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->paperSize.height =
       ConvertUnit(print_params.page_size.height(), dpi,
                   print_params.desired_dpi);
 }
 
-bool PrintingNodeOrPdfFrame(const WebFrame* frame, const WebNode& node) {
+bool PrintingNodeOrPdfFrame(const WebKit::WebFrame* frame,
+                            const WebKit::WebNode& node) {
   if (!node.isNull())
     return true;
   if (!frame->document().isPluginDocument())
     return false;
-  WebPlugin* plugin = frame->document().to<WebPluginDocument>().plugin();
+  WebKit::WebPlugin* plugin =
+      frame->document().to<WebKit::WebPluginDocument>().plugin();
   return plugin && plugin->supportsPaginatedPrint();
 }
 
-bool PrintingFrameHasPageSizeStyle(WebFrame* frame, int total_page_count) {
+bool PrintingFrameHasPageSizeStyle(WebKit::WebFrame* frame,
+                                   int total_page_count) {
   if (!frame)
     return false;
   bool frame_has_custom_page_size_style = false;
   for (int i = 0; i < total_page_count; ++i) {
     if (frame->hasCustomPageSizeStyle(i)) {
       frame_has_custom_page_size_style = true;
       break;
     }
   }
   return frame_has_custom_page_size_style;
 }
 
-printing::MarginType GetMarginsForPdf(WebFrame* frame, const WebNode& node) {
+printing::MarginType GetMarginsForPdf(WebKit::WebFrame* frame,
+                                      const WebKit::WebNode& node) {
   if (frame->isPrintScalingDisabledForPlugin(node))
     return printing::NO_MARGINS;
   else
     return printing::PRINTABLE_AREA_MARGINS;
 }
 
 bool FitToPageEnabled(const DictionaryValue& job_settings) {
   bool fit_to_paper_size = false;
   if (!job_settings.GetBoolean(printing::kSettingFitToPageEnabled,
                                &fit_to_paper_size)) {
     NOTREACHED();
   }
   return fit_to_paper_size;
 }
 
 // Get the (x, y) coordinate from where printing of the current text should
 // start depending on the horizontal alignment (LEFT, RIGHT, CENTER) and
 // vertical alignment (TOP, BOTTOM).
 SkPoint GetHeaderFooterPosition(
     float webkit_scale_factor,
-    const PageSizeMargins& page_layout,
+    const printing::PageSizeMargins& page_layout,
     printing::HorizontalHeaderFooterPosition horizontal_position,
     printing::VerticalHeaderFooterPosition vertical_position,
     double offset_to_baseline,
     double text_width_in_points) {
   SkScalar x = 0;
   switch (horizontal_position) {
     case printing::LEFT: {
       x = printing::kSettingHeaderFooterInterstice - page_layout.margin_left;
       break;
     }
     case printing::RIGHT: {
       x = page_layout.content_width + page_layout.margin_right -
           printing::kSettingHeaderFooterInterstice - text_width_in_points;
       break;
     }
     case printing::CENTER: {
-      SkScalar available_width = GetHeaderFooterSegmentWidth(
+      SkScalar available_width = printing::GetHeaderFooterSegmentWidth(
           page_layout.margin_left + page_layout.margin_right +
               page_layout.content_width);
       x = available_width - page_layout.margin_left +
           (available_width - text_width_in_points) / 2;
       break;
     }
     default: {
       NOTREACHED();
     }
   }
@@ skipping 17 matching lines @@
   return point;
 }
 
 // Given a text, the positions, and the paint object, this method gets the
 // coordinates and prints the text at those coordinates on the canvas.
 void PrintHeaderFooterText(
     const string16& text,
     WebKit::WebCanvas* canvas,
     HeaderFooterPaint paint,
     float webkit_scale_factor,
-    const PageSizeMargins& page_layout,
+    const printing::PageSizeMargins& page_layout,
     printing::HorizontalHeaderFooterPosition horizontal_position,
     printing::VerticalHeaderFooterPosition vertical_position,
     double offset_to_baseline) {
 #if defined(USE_RENDER_TEXT)
   paint->SetText(text);
   paint->SetFontSize(printing::kSettingHeaderFooterFontSize);
   double text_width_in_points = paint->GetStringSize().width();
   SkPoint point = GetHeaderFooterPosition(webkit_scale_factor, page_layout,
                                           horizontal_position,
                                           vertical_position, offset_to_baseline,
@@ skipping 28 matching lines @@
                                           vertical_position, offset_to_baseline,
                                           text_width_in_points);
   paint.setTextSize(SkDoubleToScalar(
       paint.getTextSize() / webkit_scale_factor));
   canvas->drawText(text.c_str(), text_byte_length, point.x(), point.y(),
                    paint);
 #endif
 }
 
 PrintMsg_Print_Params CalculatePrintParamsForCss(
-    WebFrame* frame,
+    WebKit::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params,
     bool ignore_css_margins,
     bool fit_to_page,
     double* scale_factor) {
   PrintMsg_Print_Params css_params = GetCssPrintParams(frame, page_index,
                                                        page_params);
 
   PrintMsg_Print_Params params = page_params;
   EnsureOrientationMatches(css_params, &params);
@@ skipping 39 matching lines @@
 }
 
 }  // namespace
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::PrintHeaderAndFooter(
     WebKit::WebCanvas* canvas,
     int page_number,
     int total_pages,
     float webkit_scale_factor,
-    const PageSizeMargins& page_layout,
-    const DictionaryValue& header_footer_info) {
+    const printing::PageSizeMargins& page_layout,
+    const DictionaryValue& header_footer_info,
+    const PrintMsg_Print_Params& params) {
   skia::VectorPlatformDeviceSkia* device =
       static_cast<skia::VectorPlatformDeviceSkia*>(canvas->getTopDevice());
   device->setDrawingArea(SkPDFDevice::kMargin_DrawingArea);
 
 #if defined(USE_RENDER_TEXT)
   scoped_ptr<gfx::RenderText> render_text(gfx::RenderText::CreateInstance());
   // TODO(asvitkine): The below line is to workaround http://crbug.com/133548.
   //                  Remove it when the underlying Skia bug has been fixed.
   render_text->set_clip_to_display_rect(false);
   gfx::FontList font_list(
@@ skipping 46 matching lines @@
                           page_layout, printing::CENTER, printing::TOP,
                           header_vertical_bounds.top());
   }
 
   // Prints the footers onto the |canvas| if there is enough space to print
   // them.
   string16 page_of_total_pages = base::IntToString16(page_number) +
                                  UTF8ToUTF16("/") +
                                  base::IntToString16(total_pages);
   string16 url;
-  if (!header_footer_info.GetString(printing::kSettingHeaderFooterURL,
-                                    &url)) {
+  if (!header_footer_info.GetString(printing::kSettingHeaderFooterURL, &url)) {
     NOTREACHED();
   }
   string16 footer_text = page_of_total_pages + url;
 
   // Used for height calculations. Note that the width may be undefined.
   SkRect footer_vertical_bounds;
 #if defined(USE_RENDER_TEXT)
   paint->SetFontList(font_list);
   paint->SetText(footer_text);
   {
@@ skipping 15 matching lines @@
     PrintHeaderFooterText(url, canvas, paint, webkit_scale_factor, page_layout,
                           printing::LEFT, printing::BOTTOM,
                           footer_vertical_bounds.bottom());
   }
 
   device->setDrawingArea(SkPDFDevice::kContent_DrawingArea);
 }
 
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& print_params,
-    WebFrame* frame,
-    const WebNode& node)
+    WebKit::WebFrame* frame,
+    const WebKit::WebNode& node)
         : frame_(frame),
           node_to_print_(node),
           web_view_(frame->view()),
           expected_pages_count_(0),
           use_browser_overlays_(true),
           finished_(false) {
-  WebPrintParams webkit_print_params;
+  WebKit::WebPrintParams webkit_print_params;
   ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
 
-  if (WebFrame* web_frame = web_view_->mainFrame())
+  if (WebKit::WebFrame* web_frame = web_view_->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view_->size();
 
   StartPrinting(webkit_print_params);
 }
 
 PrepareFrameAndViewForPrint::~PrepareFrameAndViewForPrint() {
   FinishPrinting();
 }
 
 void PrepareFrameAndViewForPrint::UpdatePrintParams(
     const PrintMsg_Print_Params& print_params) {
   DCHECK(!finished_);
-  WebPrintParams webkit_print_params;
+  WebKit::WebPrintParams webkit_print_params;
   ComputeWebKitPrintParamsInDesiredDpi(print_params, &webkit_print_params);
 
   if (webkit_print_params.printContentArea ==
           web_print_params_.printContentArea &&
       webkit_print_params.printableArea == web_print_params_.printableArea &&
       webkit_print_params.paperSize == web_print_params_.paperSize &&
       webkit_print_params.printScalingOption ==
           web_print_params_.printScalingOption) {
     return;
   }
 
   frame_->printEnd();
   StartPrinting(webkit_print_params);
 }
 
+gfx::Size PrepareFrameAndViewForPrint::GetPrintCanvasSize() const {
+  return gfx::Size(web_print_params_.printContentArea.width,
+                   web_print_params_.printContentArea.height);
+}
+
 void PrepareFrameAndViewForPrint::StartPrinting(
-    const WebPrintParams& webkit_print_params) {
+    const WebKit::WebPrintParams& webkit_print_params) {
   web_print_params_ = webkit_print_params;
 
   // Layout page according to printer page size. Since WebKit shrinks the
   // size of the page automatically (from 125% to 200%) we trick it to
   // think the page is 125% larger so the size of the page is correct for
   // minimum (default) scaling.
   // This is important for sites that try to fill the page.
   gfx::Size print_layout_size(web_print_params_.printContentArea.width,
                               web_print_params_.printContentArea.height);
   print_layout_size.set_height(static_cast<int>(
       static_cast<double>(print_layout_size.height()) * 1.25));
 
   web_view_->resize(print_layout_size);
 
   expected_pages_count_ = frame_->printBegin(web_print_params_,
                                              node_to_print_,
                                              &use_browser_overlays_);
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
   if (!finished_) {
     finished_ = true;
     frame_->printEnd();
     web_view_->resize(prev_view_size_);
-    if (WebFrame* web_frame = web_view_->mainFrame())
+    if (WebKit::WebFrame* web_frame = web_view_->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
       is_preview_enabled_(IsPrintPreviewEnabled()),
       is_scripted_print_throttling_disabled_(IsPrintThrottlingDisabled()),
@@ skipping 34 matching lines @@
   }
 
   if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
     return;
   IncrementScriptedPrintCount();
 
   if (is_preview_enabled_) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
   } else {
-    Print(frame, WebNode());
+    Print(frame, WebKit::WebNode());
   }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintNodeUnderContextMenu,
@@ skipping 12 matching lines @@
 
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const DictionaryValue& job_settings) {
   DCHECK(is_preview_enabled_);
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
   if (!render_view()->GetWebView())
     return;
-  WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  WebKit::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (!main_frame)
     return;
 
-  WebDocument document = main_frame->document();
+  WebKit::WebDocument document = main_frame->document();
   // <object> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview/print_preview.js
-  WebElement pdf_element = document.getElementById("pdf-viewer");
+  WebKit::WebElement pdf_element = document.getElementById("pdf-viewer");
   if (pdf_element.isNull()) {
     NOTREACHED();
     return;
   }
 
   // Set |print_for_preview_| flag and autoreset it to back to original
   // on return.
   AutoReset<bool> set_printing_flag(&print_for_preview_, true);
 
-  WebFrame* pdf_frame = pdf_element.document().frame();
+  WebKit::WebFrame* pdf_frame = pdf_element.document().frame();
   if (!UpdatePrintSettings(pdf_frame, pdf_element, job_settings)) {
     LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Print page onto entire page not just printable area. Preview PDF already
   // has content in correct position taking into account page size and printable
   // area.
   // TODO(vitalybuka) : Make this consistent on all platform. This change
@@ skipping 20 matching lines @@
 
   // If the user has selected text in the currently focused frame we print
   // only that frame (this makes print selection work for multiple frames).
   *frame = render_view()->GetWebView()->focusedFrame()->hasSelection() ?
       render_view()->GetWebView()->focusedFrame() :
       render_view()->GetWebView()->mainFrame();
   return true;
 }
 
 void PrintWebViewHelper::OnPrintPages() {
-  WebFrame* frame;
+  WebKit::WebFrame* frame;
   if (GetPrintFrame(&frame))
-    Print(frame, WebNode());
+    Print(frame, WebKit::WebNode());
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
-  WebFrame* frame = print_preview_context_.frame();
+  WebKit::WebFrame* frame = print_preview_context_.frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
   Print(frame, print_preview_context_.node());
 }
 
 void PrintWebViewHelper::GetPageSizeAndContentAreaFromPageLayout(
     const printing::PageSizeMargins& page_layout_in_points,
@@ skipping 10 matching lines @@
                             page_layout_in_points.margin_top,
                             page_layout_in_points.content_width,
                             page_layout_in_points.content_height);
 }
 
 void PrintWebViewHelper::UpdateFrameMarginsCssInfo(
     const DictionaryValue& settings) {
   int margins_type = 0;
   if (!settings.GetInteger(printing::kSettingMarginsType, &margins_type))
     margins_type = printing::DEFAULT_MARGINS;
-  ignore_css_margins_ = margins_type != printing::DEFAULT_MARGINS;
+  ignore_css_margins_ = (margins_type != printing::DEFAULT_MARGINS);
 }
 
 bool PrintWebViewHelper::IsPrintToPdfRequested(
     const DictionaryValue& job_settings) {
   bool print_to_pdf = false;
   if (!job_settings.GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf))
     NOTREACHED();
   return print_to_pdf;
 }
 
@@ skipping 80 matching lines @@
   if (CreatePreviewDocument()) {
     DidFinishPrinting(OK);
   } else {
     if (notify_browser_of_print_failure_)
       LOG(ERROR) << "CreatePreviewDocument failed";
     DidFinishPrinting(FAIL_PREVIEW);
   }
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
-  PrintMsg_Print_Params print_params = print_pages_params_->params;
+  const PrintMsg_Print_Params& print_params = print_pages_params_->params;
   const std::vector<int>& pages = print_pages_params_->pages;
-  if (!print_preview_context_.CreatePreviewDocument(&print_params, pages,
+  if (!print_preview_context_.CreatePreviewDocument(print_params, pages,
                                                     ignore_css_margins_)) {
     return false;
   }
 
-  PageSizeMargins default_page_layout;
+  printing::PageSizeMargins default_page_layout;
   ComputePageLayoutInPointsForCss(print_preview_context_.frame(), 0,
                                   print_params, ignore_css_margins_, NULL,
                                   &default_page_layout);
 
   if (!old_print_pages_params_.get() ||
       !PageLayoutIsEqual(*old_print_pages_params_, *print_pages_params_)) {
     bool has_page_size_style = PrintingFrameHasPageSizeStyle(
         print_preview_context_.frame(),
         print_preview_context_.total_page_count());
     int dpi = GetDPI(&print_params);
+
+    using printing::ConvertUnit;
+    using printing::kPointsPerInch;
     gfx::Rect printable_area_in_points(
-      ConvertUnit(print_pages_params_->params.printable_area.x(),
-          dpi, printing::kPointsPerInch),
-      ConvertUnit(print_pages_params_->params.printable_area.y(),
-          dpi, printing::kPointsPerInch),
-      ConvertUnit(print_pages_params_->params.printable_area.width(),
-          dpi, printing::kPointsPerInch),
-      ConvertUnit(print_pages_params_->params.printable_area.height(),
-          dpi, printing::kPointsPerInch));
+        ConvertUnit(print_params.printable_area.x(), dpi, kPointsPerInch),
+        ConvertUnit(print_params.printable_area.y(), dpi, kPointsPerInch),
+        ConvertUnit(print_params.printable_area.width(), dpi, kPointsPerInch),
+        ConvertUnit(print_params.printable_area.height(), dpi, kPointsPerInch));
 
     // Margins: Send default page layout to browser process.
     Send(new PrintHostMsg_DidGetDefaultPageLayout(routing_id(),
                                                   default_page_layout,
                                                   printable_area_in_points,
                                                   has_page_size_style));
   }
 
   PrintHostMsg_DidGetPreviewPageCount_Params params;
   params.page_count = print_preview_context_.total_page_count();
   params.is_modifiable = print_preview_context_.IsModifiable();
-  params.document_cookie = print_pages_params_->params.document_cookie;
-  params.preview_request_id = print_pages_params_->params.preview_request_id;
+  params.document_cookie = print_params.document_cookie;
+  params.preview_request_id = print_params.preview_request_id;
   params.clear_preview_data = print_preview_context_.generate_draft_pages();
   Send(new PrintHostMsg_DidGetPreviewPageCount(routing_id(), params));
   if (CheckForCancel())
     return false;
 
   while (!print_preview_context_.IsFinalPageRendered()) {
     int page_number = print_preview_context_.GetNextPageNumber();
     DCHECK_GE(page_number, 0);
-    if (!RenderPreviewPage(page_number))
+    if (!RenderPreviewPage(page_number, print_params))
       return false;
 
     if (CheckForCancel())
       return false;
 
     // We must call PrepareFrameAndViewForPrint::FinishPrinting() (by way of
     // print_preview_context_.AllPagesRendered()) before calling
     // FinalizePrintReadyDocument() when printing a PDF because the plugin
     // code does not generate output until we call FinishPrinting().  We do not
     // generate draft pages for PDFs, so IsFinalPageRendered() and
@@ skipping 50 matching lines @@
   if (!success)
     LOG(ERROR) << "Failure in OnPrintingDone";
   DidFinishPrinting(success ? OK : FAIL_PRINT);
 }
 
 void PrintWebViewHelper::SetScriptedPrintBlocked(bool blocked) {
   is_scripted_printing_blocked_ = blocked;
 }
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
-  const WebNode& context_menu_node = render_view()->GetContextMenuNode();
-  PrintNode(context_menu_node);
+  PrintNode(render_view()->GetContextMenuNode());
 }
 
 void PrintWebViewHelper::OnInitiatePrintPreview() {
   DCHECK(is_preview_enabled_);
-  WebFrame* frame;
+  WebKit::WebFrame* frame;
   if (GetPrintFrame(&frame)) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME);
   } else {
     // This should not happen. Let's add a CHECK here to see how often this
     // gets hit.
     // TODO(thestig) Remove this later when we have sufficient usage of this
     // code on the M19 stable channel.
     CHECK(false);
   }
 }
 
-void PrintWebViewHelper::PrintNode(const WebNode& node) {
+void PrintWebViewHelper::PrintNode(const WebKit::WebNode& node) {
   if (node.isNull() || !node.document().frame()) {
     // This can occur when the context menu refers to an invalid WebNode.
     // See http://crbug.com/100890#c17 for a repro case.
     return;
   }
 
   // Make a copy of the node, in case RenderView::OnContextMenuClosed resets
   // its |context_menu_node_|.
   if (is_preview_enabled_) {
     print_preview_context_.InitWithNode(node);
     RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
   } else {
-    WebNode duplicate_node(node);
+    WebKit::WebNode duplicate_node(node);
     Print(duplicate_node.document().frame(), duplicate_node);
   }
 }
 
 void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
                                const WebKit::WebNode& node) {
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
@@ skipping 82 matching lines @@
 }
 
 bool PrintWebViewHelper::CopyAndPrint(WebKit::WebFrame* web_frame) {
   // Create a new WebView with the same settings as the current display one.
   // Except that we disable javascript (don't want any active content running
   // on the page).
   webkit_glue::WebPreferences prefs = render_view()->GetWebkitPreferences();
   prefs.javascript_enabled = false;
   prefs.java_enabled = false;
 
-  print_web_view_ = WebView::create(this);
+  print_web_view_ = WebKit::WebView::create(this);
   prefs.Apply(print_web_view_);
   print_web_view_->initializeMainFrame(this);
 
   print_pages_params_->pages.clear();  // Print all pages of selection.
 
   std::string html = web_frame->selectionAsMarkup().utf8();
   std::string url_str = "data:text/html;charset=utf-8,";
   url_str.append(html);
   GURL url(url_str);
 
   // When loading is done this will call didStopLoading() and that will do the
   // actual printing.
-  print_web_view_->mainFrame()->loadRequest(WebURLRequest(url));
+  print_web_view_->mainFrame()->loadRequest(WebKit::WebURLRequest(url));
 
   return true;
 }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
-bool PrintWebViewHelper::PrintPages(WebFrame* frame, const WebNode& node) {
+bool PrintWebViewHelper::PrintPages(WebKit::WebFrame* frame,
+                                    const WebKit::WebNode& node) {
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   PrepareFrameAndViewForPrint prep_frame_view(print_params, frame, node);
   UpdateFrameAndViewFromCssPageLayout(frame, node, &prep_frame_view,
                                       print_params, ignore_css_margins_);
 
   int page_count = prep_frame_view.GetExpectedPageCount();
   if (!page_count)
     return false;
   Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
@@ skipping 14 matching lines @@
         break;
       page_params.page_number = params.pages[i];
       PrintPageInternal(page_params, canvas_size, frame);
     }
   }
   return true;
 }
 #endif  // OS_MACOSX || OS_WIN
 
 void PrintWebViewHelper::didStopLoading() {
-  PrintPages(print_web_view_->mainFrame(), WebNode());
+  PrintPages(print_web_view_->mainFrame(), WebKit::WebNode());
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::ComputePageLayoutInPointsForCss(
-    WebFrame* frame,
+    WebKit::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params,
     bool ignore_css_margins,
     double* scale_factor,
-    PageSizeMargins* page_layout_in_points) {
+    printing::PageSizeMargins* page_layout_in_points) {
   PrintMsg_Print_Params params = CalculatePrintParamsForCss(
       frame, page_index, page_params, ignore_css_margins,
       page_params.print_scaling_option ==
           WebKit::WebPrintScalingOptionFitToPrintableArea,
       scale_factor);
   CalculatePageLayoutFromPrintParams(params, page_layout_in_points);
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::UpdateFrameAndViewFromCssPageLayout(
-    WebFrame* frame,
-    const WebNode& node,
+    WebKit::WebFrame* frame,
+    const WebKit::WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
     const PrintMsg_Print_Params& params,
     bool ignore_css_margins) {
   if (PrintingNodeOrPdfFrame(frame, node))
     return;
   bool fit_to_page = ignore_css_margins &&
                      params.print_scaling_option ==
                           WebKit::WebPrintScalingOptionFitToPrintableArea;
   PrintMsg_Print_Params print_params = CalculatePrintParamsForCss(
       frame, 0, params, ignore_css_margins, fit_to_page, NULL);
@@ skipping 27 matching lines @@
   if (fit_to_paper_size) {
     settings.params.print_scaling_option =
         WebKit::WebPrintScalingOptionFitToPrintableArea;
   }
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   return result;
 }
 
 bool PrintWebViewHelper::InitPrintSettingsAndPrepareFrame(
-    WebKit::WebFrame* frame, const WebKit::WebNode& node,
+    WebKit::WebFrame* frame,
+    const WebKit::WebNode& node,
     scoped_ptr<PrepareFrameAndViewForPrint>* prepare) {
   DCHECK(frame);
 
   bool fit_to_paper_size = !(PrintingNodeOrPdfFrame(frame, node));
   if (!InitPrintSettings(fit_to_paper_size)) {
     notify_browser_of_print_failure_ = false;
     render_view()->RunModalAlertDialog(
         frame,
         l10n_util::GetStringUTF16(IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
     return false;
   }
 
   DCHECK(!prepare->get());
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
   UpdateFrameAndViewFromCssPageLayout(frame, node, prepare->get(),
                                       print_pages_params_->params,
                                       ignore_css_margins_);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
-    WebKit::WebFrame* frame, const WebKit::WebNode& node,
+    WebKit::WebFrame* frame,
+    const WebKit::WebNode& node,
     const DictionaryValue& passed_job_settings) {
   DCHECK(is_preview_enabled_);
   const DictionaryValue* job_settings = &passed_job_settings;
   DictionaryValue modified_job_settings;
   if (job_settings->empty()) {
     if (!print_for_preview_)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
@@ skipping 169 matching lines @@
           kMaxSecondsToIgnoreJavascriptInitiatedPrint);
     }
     if (diff.InSeconds() < min_wait_seconds) {
       too_frequent = true;
     }
   }
 
   if (!too_frequent)
     return false;
 
-  WebString message(WebString::fromUTF8(
-      "Ignoring too frequent calls to print()."));
-  frame->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelWarning,
-                                               message));
+  WebKit::WebString message(
+      WebKit::WebString::fromUTF8("Ignoring too frequent calls to print()."));
+  frame->addMessageToConsole(
+      WebKit::WebConsoleMessage(
+          WebKit::WebConsoleMessage::LevelWarning, message));
   return true;
 }
 
 void PrintWebViewHelper::ResetScriptedPrintCount() {
   // Reset cancel counter on successful print.
   user_cancelled_scripted_print_count_ = 0;
 }
 
 void PrintWebViewHelper::IncrementScriptedPrintCount() {
   ++user_cancelled_scripted_print_count_;
@@ skipping 110 matching lines @@
   frame_ = web_node.document().frame();
   node_ = web_node;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
-    PrintMsg_Print_Params* print_params,
+    const PrintMsg_Print_Params& print_params,
     const std::vector<int>& pages,
     bool ignore_css_margins) {
   DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   metafile_.reset(new printing::PreviewMetafile);
   if (!metafile_->Init()) {
     set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
     LOG(ERROR) << "PreviewMetafile Init failed";
     return false;
   }
 
   // Need to make sure old object gets destroyed first.
-  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(*print_params, frame(),
+  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(print_params, frame(),
                                                          node()));
   UpdateFrameAndViewFromCssPageLayout(frame_, node_, prep_frame_view_.get(),
-                                      *print_params, ignore_css_margins);
-
-  print_params_.reset(new PrintMsg_Print_Params(*print_params));
+                                      print_params, ignore_css_margins);
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
   if (total_page_count_ == 0) {
     LOG(ERROR) << "CreatePreviewDocument got 0 page count";
     set_error(PREVIEW_ERROR_ZERO_PAGES);
     return false;
   }
 
   int selected_page_count = pages.size();
   current_page_index_ = 0;
@@ skipping 130 matching lines @@
 
 bool PrintWebViewHelper::PrintPreviewContext::generate_draft_pages() const {
   return generate_draft_pages_;
 }
 
 printing::PreviewMetafile* PrintWebViewHelper::PrintPreviewContext::metafile() {
   DCHECK(IsRendering());
   return metafile_.get();
 }
 
-const PrintMsg_Print_Params&
-PrintWebViewHelper::PrintPreviewContext::print_params() const {
-  DCHECK(state_ != UNINITIALIZED);
-  return *print_params_;
-}
-
 int PrintWebViewHelper::PrintPreviewContext::last_error() const {
   return error_;
 }
 
 gfx::Size PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   DCHECK(IsRendering());
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }