"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 printing::kPixelsPerInch;
+using printing::kPointsPerInch;
 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;
 
 int GetDPI(const PrintMsg_Print_Params* print_params) {
 #if defined(OS_MACOSX)
   // On the Mac, the printable area is in points, don't do any scaling based
   // on dpi.
-  return printing::kPointsPerInch;
+  return kPointsPerInch;
 #else
   return static_cast<int>(print_params->dpi);
 #endif  // defined(OS_MACOSX)
 }
 
 bool PrintMsg_Print_Params_IsValid(const PrintMsg_Print_Params& params) {
   return !params.content_size.IsEmpty() && !params.page_size.IsEmpty() &&
          !params.printable_area.IsEmpty() && params.document_cookie &&
          params.desired_dpi && params.max_shrink && params.min_shrink &&
          params.dpi && (params.margin_top >= 0) && (params.margin_left >= 0);
@@ skipping 31 matching lines @@
          std::equal(oldParams.pages.begin(), oldParams.pages.end(),
              newParams.pages.begin());
 }
 
 PrintMsg_Print_Params GetCssPrintParams(
     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);
+  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 32 matching lines @@
     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);
+  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;
 
   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);
@@ skipping 17 matching lines @@
   webkit_print_params->paperSize.height =
       ConvertUnit(print_params.page_size.height(), dpi,
                   print_params.desired_dpi);
 }
 
 bool PrintingNodeOrPdfFrame(const WebFrame* frame, const 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) {
   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;
@@ skipping 34 matching lines @@
     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 127 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 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 23 matching lines @@
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& print_params,
     WebFrame* frame,
     const 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())
     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>(
@@ skipping 26 matching lines @@
       ignore_css_margins_(false),
       user_cancelled_scripted_print_count_(0),
       is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
-    WebKit::WebFrame* frame, bool user_initiated) {

[Lei Zhang, 2012/11/01 19:21:42]

If you don't mind, can we keep this one and the ones below as WebKit::WebFoo in
the method declaration, so the .h and .cc files match?

[Vitaly Buka (NO REVIEWS), 2012/11/01 19:55:56]

Then we don't need these usings, most of them interfaces.

+    WebFrame* frame, bool user_initiated) {
   if (is_scripted_printing_blocked_)
     return false;
   // If preview is enabled, then the print dialog is tab modal, and the user
   // can always close the tab on a mis-behaving page (the system print dialog
   // is app modal). If the print was initiated through user action, don't
   // throttle. Or, if the command line flag to skip throttling has been set.
   if (!is_scripted_print_throttling_disabled_ &&
       !is_preview_enabled_ &&
       !user_initiated)
     return !IsScriptInitiatedPrintTooFrequent(frame);
   return true;
 }
 
 // Prints |frame| which called window.print().
-void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame,
+void PrintWebViewHelper::PrintPage(WebFrame* frame,
                                    bool user_initiated) {
   DCHECK(frame);
 
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(render_view())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
   if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
@@ skipping 34 matching lines @@
   // 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();
   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();
@@ skipping 15 matching lines @@
   PrintMsg_Print_Params& print_params = print_pages_params_->params;
   print_params.printable_area = gfx::Rect(print_params.page_size);
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(pdf_frame, pdf_element)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
 }
 
-bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
+bool PrintWebViewHelper::GetPrintFrame(WebFrame** frame) {
   DCHECK(frame);
   DCHECK(render_view()->GetWebView());
   if (!render_view()->GetWebView())
     return false;
 
   // 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();
@@ skipping 10 matching lines @@
   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,
+    const PageSizeMargins& page_layout_in_points,
     gfx::Size* page_size,
     gfx::Rect* content_area) {
   *page_size = gfx::Size(
       page_layout_in_points.content_width +
           page_layout_in_points.margin_right +
           page_layout_in_points.margin_left,
       page_layout_in_points.content_height +
           page_layout_in_points.margin_top +
           page_layout_in_points.margin_bottom);
   *content_area = gfx::Rect(page_layout_in_points.margin_left,
                             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;
   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);
     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 87 matching lines @@
   // 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);
     Print(duplicate_node.document().frame(), duplicate_node);
   }
 }
 
-void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
-                               const WebKit::WebNode& node) {
+void PrintWebViewHelper::Print(WebFrame* frame,
+                               const WebNode& node) {
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
   // Initialize print settings.
   scoped_ptr<PrepareFrameAndViewForPrint> prepare;
   if (!InitPrintSettingsAndPrepareFrame(frame, node, &prepare)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
@@ skipping 68 matching lines @@
   if (store_print_pages_params) {
     old_print_pages_params_.reset(print_pages_params_.release());
   } else {
     print_pages_params_.reset();
     old_print_pages_params_.reset();
   }
 
   notify_browser_of_print_failure_ = true;
 }
 
-bool PrintWebViewHelper::CopyAndPrint(WebKit::WebFrame* web_frame) {
+bool PrintWebViewHelper::CopyAndPrint(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) {
   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,
@@ skipping 90 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,
+    WebFrame* frame, const 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,
+    WebFrame* frame, const 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 23 matching lines @@
   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_IsValid(settings.params)) {
     if (!print_for_preview_) {
       print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
     } else {
       // PrintForPrintPreview
-      WebKit::WebFrame* print_frame = NULL;
+      WebFrame* print_frame = NULL;
       // This may not be the right frame, but the alert will be modal,
       // therefore it works well enough.
       GetPrintFrame(&print_frame);
       if (print_frame) {
         render_view()->RunModalAlertDialog(
             print_frame,
             l10n_util::GetStringUTF16(
                 IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
       }
     }
@@ skipping 34 matching lines @@
                                      settings.params.title);
     }
   }
 
   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,
-                                                  const WebKit::WebNode& node,
+bool PrintWebViewHelper::GetPrintSettingsFromUser(WebFrame* frame,
+                                                  const WebNode& node,
                                                   int expected_pages_count,
                                                   bool use_browser_overlays) {
   PrintHostMsg_ScriptedPrint_Params params;
   PrintMsg_PrintPages_Params print_settings;
 
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   printing::MarginType margin_type = printing::DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
@@ skipping 12 matching lines @@
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
 
   print_pages_params_->params.print_scaling_option = scaling_option;
   return (print_settings.params.dpi && print_settings.params.document_cookie);
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(
-    WebKit::WebFrame* frame,
-    const WebKit::WebNode& node) {
+    WebFrame* frame,
+    const WebNode& node) {
   if (print_pages_params_->params.selection_only)
     return CopyAndPrint(frame);
   return PrintPages(frame, node);
 }
 
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     printing::Metafile* metafile,
     base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   base::SharedMemoryHandle mem_handle =
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(buf_size);
   if (base::SharedMemory::IsHandleValid(mem_handle)) {
     base::SharedMemory shared_buf(mem_handle, false);
     if (shared_buf.Map(buf_size)) {
       metafile->GetData(shared_buf.memory(), buf_size);
       shared_buf.GiveToProcess(base::GetCurrentProcessHandle(),
                                shared_mem_handle);
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 #endif  // defined(OS_POSIX)
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintTooFrequent(
-    WebKit::WebFrame* frame) {
+    WebFrame* frame) {
   const int kMinSecondsToIgnoreJavascriptInitiatedPrint = 2;
   const int kMaxSecondsToIgnoreJavascriptInitiatedPrint = 32;
   bool too_frequent = false;
 
   // Check if there is script repeatedly trying to print and ignore it if too
   // frequent.  The first 3 times, we use a constant wait time, but if this
   // gets excessive, we switch to exponential wait time. So for a page that
   // calls print() in a loop the user will need to cancel the print dialog
   // after: [2, 2, 2, 4, 8, 16, 32, 32, ...] seconds.
   // This gives the user time to navigate from the page.
   if (user_cancelled_scripted_print_count_ > 0) {
     base::TimeDelta diff = base::Time::Now() - last_cancelled_script_print_;
     int min_wait_seconds = kMinSecondsToIgnoreJavascriptInitiatedPrint;
     if (user_cancelled_scripted_print_count_ > 3) {
       min_wait_seconds = std::min(
           kMinSecondsToIgnoreJavascriptInitiatedPrint <<
               (user_cancelled_scripted_print_count_ - 3),
           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 86 matching lines @@
       generate_draft_pages_(true),
       print_ready_metafile_page_count_(0),
       error_(PREVIEW_ERROR_NONE),
       state_(UNINITIALIZED) {
 }
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
-    WebKit::WebFrame* web_frame) {
+    WebFrame* web_frame) {
   DCHECK(web_frame);
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   frame_ = web_frame;
   node_.reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
-    const WebKit::WebNode& web_node) {
+    const WebNode& web_node) {
   DCHECK(!web_node.isNull());
   DCHECK(web_node.document().frame());
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   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 104 matching lines @@
     bool generate_draft_pages) {
   DCHECK_EQ(INITIALIZED, state_);
   generate_draft_pages_ = generate_draft_pages;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_error(
     enum PrintPreviewErrorBuckets error) {
   error_ = error;
 }
 
-WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() {
+WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() {
   // TODO(thestig) turn this back into a DCHECK when http://crbug.com/118303 is
   // resolved.
   CHECK(state_ != UNINITIALIZED);
   return frame_;
 }
 
-const WebKit::WebNode& PrintWebViewHelper::PrintPreviewContext::node() const {
+const WebNode& PrintWebViewHelper::PrintPreviewContext::node() const {
   DCHECK(state_ != UNINITIALIZED);
   return node_;
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
   DCHECK(state_ != UNINITIALIZED);
   return total_page_count_;
 }
 
 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;
 }