Rename WebKit namespace to blink (part 4)

chrome/renderer/printing/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/printing/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 50 matching lines @@
   PREVIEW_EVENT_MAX,
 };
 
 const double kMinDpi = 1.0;
 
 const char kPageLoadScriptFormat[] =
     "document.open(); document.write(%s); document.close();";
 
 const char kPageSetupScriptFormat[] = "setup(%s);";
 
-void ExecuteScript(WebKit::WebFrame* frame,
+void ExecuteScript(blink::WebFrame* frame,
                    const char* script_format,
                    const base::Value& parameters) {
   std::string json;
   base::JSONWriter::Write(&parameters, &json);
   std::string script = base::StringPrintf(script_format, json.c_str());
-  frame->executeScript(WebKit::WebString(UTF8ToUTF16(script)));
+  frame->executeScript(blink::WebString(UTF8ToUTF16(script)));
 }
 
 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 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);
 }
 
 PrintMsg_Print_Params GetCssPrintParams(
-    WebKit::WebFrame* frame,
+    blink::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params) {
   PrintMsg_Print_Params page_css_params = page_params;
   int dpi = GetDPI(&page_params);
 
-  WebKit::WebSize page_size_in_pixels(
+  blink::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, kPixelsPerInch);
   int margin_bottom_in_pixels = ConvertUnit(
       page_params.page_size.height() -
       page_params.content_size.height() - page_params.margin_top,
       dpi, kPixelsPerInch);
   int margin_left_in_pixels = ConvertUnit(
       page_params.margin_left,
       dpi, kPixelsPerInch);
 
-  WebKit::WebSize original_page_size_in_pixels = page_size_in_pixels;
+  blink::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);
   }
 
@@ skipping 106 matching lines @@
                                  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,
-    WebKit::WebPrintParams* webkit_print_params) {
+    blink::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 12 matching lines @@
                   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);
 }
 
-WebKit::WebPlugin* GetPlugin(const WebKit::WebFrame* frame) {
+blink::WebPlugin* GetPlugin(const blink::WebFrame* frame) {
   return frame->document().isPluginDocument() ?
-         frame->document().to<WebKit::WebPluginDocument>().plugin() : NULL;
+         frame->document().to<blink::WebPluginDocument>().plugin() : NULL;
 }
 
-bool PrintingNodeOrPdfFrame(const WebKit::WebFrame* frame,
-                            const WebKit::WebNode& node) {
+bool PrintingNodeOrPdfFrame(const blink::WebFrame* frame,
+                            const blink::WebNode& node) {
   if (!node.isNull())
     return true;
-  WebKit::WebPlugin* plugin = GetPlugin(frame);
+  blink::WebPlugin* plugin = GetPlugin(frame);
   return plugin && plugin->supportsPaginatedPrint();
 }
 
-bool PrintingFrameHasPageSizeStyle(WebKit::WebFrame* frame,
+bool PrintingFrameHasPageSizeStyle(blink::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;
 }
 
-MarginType GetMarginsForPdf(WebKit::WebFrame* frame,
-                            const WebKit::WebNode& node) {
+MarginType GetMarginsForPdf(blink::WebFrame* frame,
+                            const blink::WebNode& node) {
   if (frame->isPrintScalingDisabledForPlugin(node))
     return NO_MARGINS;
   else
     return PRINTABLE_AREA_MARGINS;
 }
 
 bool FitToPageEnabled(const base::DictionaryValue& job_settings) {
   bool fit_to_paper_size = false;
   if (!job_settings.GetBoolean(kSettingFitToPageEnabled, &fit_to_paper_size)) {
     NOTREACHED();
   }
   return fit_to_paper_size;
 }
 
 PrintMsg_Print_Params CalculatePrintParamsForCss(
-    WebKit::WebFrame* frame,
+    blink::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 33 matching lines @@
       switches::kRendererPrintPreview);
 }
 
 bool IsPrintThrottlingDisabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableScriptedPrintThrottling);
 }
 
 }  // namespace
 
-FrameReference::FrameReference(const WebKit::WebFrame* frame) {
+FrameReference::FrameReference(const blink::WebFrame* frame) {
   Reset(frame);
 }
 
 FrameReference::FrameReference() {
   Reset(NULL);
 }
 
 FrameReference::~FrameReference() {
 }
 
-void FrameReference::Reset(const WebKit::WebFrame* frame) {
+void FrameReference::Reset(const blink::WebFrame* frame) {
   if (frame) {
     view_ = frame->view();
     frame_name_ = frame->uniqueName();
   } else {
     view_ = NULL;
     frame_name_.reset();
   }
 }
 
-WebKit::WebFrame* FrameReference::GetFrame() {
+blink::WebFrame* FrameReference::GetFrame() {
   return view_ ? view_->findFrameByName(frame_name_) : NULL;
 }
 
-WebKit::WebView* FrameReference::view() {
+blink::WebView* FrameReference::view() {
   return view_;
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::PrintHeaderAndFooter(
-    WebKit::WebCanvas* canvas,
+    blink::WebCanvas* canvas,
     int page_number,
     int total_pages,
     float webkit_scale_factor,
     const PageSizeMargins& page_layout,
     const base::DictionaryValue& header_footer_info,
     const PrintMsg_Print_Params& params) {
   skia::VectorPlatformDeviceSkia* device =
       static_cast<skia::VectorPlatformDeviceSkia*>(canvas->getTopDevice());
   device->setDrawingArea(SkPDFDevice::kMargin_DrawingArea);
 
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->scale(1 / webkit_scale_factor, 1 / webkit_scale_factor);
 
-  WebKit::WebSize page_size(page_layout.margin_left + page_layout.margin_right +
+  blink::WebSize page_size(page_layout.margin_left + page_layout.margin_right +
                             page_layout.content_width,
                             page_layout.margin_top + page_layout.margin_bottom +
                             page_layout.content_height);
 
-  WebKit::WebView* web_view = WebKit::WebView::create(NULL);
+  blink::WebView* web_view = blink::WebView::create(NULL);
   web_view->settings()->setJavaScriptEnabled(true);
   web_view->initializeMainFrame(NULL);
 
-  WebKit::WebFrame* frame = web_view->mainFrame();
+  blink::WebFrame* frame = web_view->mainFrame();
 
   base::StringValue html(
       ResourceBundle::GetSharedInstance().GetLocalizedString(
           IDR_PRINT_PREVIEW_PAGE));
   // Load page with script to avoid async operations.
   ExecuteScript(frame, kPageLoadScriptFormat, html);
 
   scoped_ptr<base::DictionaryValue> options(header_footer_info.DeepCopy());
   options->SetDouble("width", page_size.width);
   options->SetDouble("height", page_size.height);
   options->SetDouble("topMargin", page_layout.margin_top);
   options->SetDouble("bottomMargin", page_layout.margin_bottom);
   options->SetString("pageNumber",
                      base::StringPrintf("%d/%d", page_number, total_pages));
 
   ExecuteScript(frame, kPageSetupScriptFormat, *options);
 
-  WebKit::WebPrintParams webkit_params(page_size);
+  blink::WebPrintParams webkit_params(page_size);
   webkit_params.printerDPI = GetDPI(&params);
 
   frame->printBegin(webkit_params);
   frame->printPage(0, canvas);
   frame->printEnd();
 
   web_view->close();
 
   device->setDrawingArea(SkPDFDevice::kContent_DrawingArea);
 }
 
 // static - Not anonymous so that platform implementations can use it.
-float PrintWebViewHelper::RenderPageContent(WebKit::WebFrame* frame,
+float PrintWebViewHelper::RenderPageContent(blink::WebFrame* frame,
                                             int page_number,
                                             const gfx::Rect& canvas_area,
                                             const gfx::Rect& content_area,
                                             double scale_factor,
-                                            WebKit::WebCanvas* canvas) {
+                                            blink::WebCanvas* canvas) {
   SkAutoCanvasRestore auto_restore(canvas, true);
   if (content_area != canvas_area) {
     canvas->translate((content_area.x() - canvas_area.x()) / scale_factor,
                       (content_area.y() - canvas_area.y()) / scale_factor);
     SkRect clip_rect(
         SkRect::MakeXYWH(content_area.origin().x() / scale_factor,
                          content_area.origin().y() / scale_factor,
                          content_area.size().width() / scale_factor,
                          content_area.size().height() / scale_factor));
     SkIRect clip_int_rect;
     clip_rect.roundOut(&clip_int_rect);
     SkRegion clip_region(clip_int_rect);
     canvas->setClipRegion(clip_region);
   }
   return frame->printPage(page_number, canvas);
 }
 
 // Class that calls the Begin and End print functions on the frame and changes
 // the size of the view temporarily to support full page printing..
-class PrepareFrameAndViewForPrint : public WebKit::WebViewClient,
-                                    public WebKit::WebFrameClient {
+class PrepareFrameAndViewForPrint : public blink::WebViewClient,
+                                    public blink::WebFrameClient {
  public:
   PrepareFrameAndViewForPrint(const PrintMsg_Print_Params& params,
-                              WebKit::WebFrame* frame,
-                              const WebKit::WebNode& node,
+                              blink::WebFrame* frame,
+                              const blink::WebNode& node,
                               bool ignore_css_margins);
   virtual ~PrepareFrameAndViewForPrint();
 
   // Optional. Replaces |frame_| with selection if needed. Will call |on_ready|
   // when completed.
   void CopySelectionIfNeeded(const WebPreferences& preferences,
                              const base::Closure& on_ready);
 
   // Prepares frame for printing.
   void StartPrinting();
 
-  WebKit::WebFrame* frame() {
+  blink::WebFrame* frame() {
     return frame_.GetFrame();
   }
 
-  const WebKit::WebNode& node() const {
+  const blink::WebNode& node() const {
     return node_to_print_;
   }
 
   int GetExpectedPageCount() const {
     return expected_pages_count_;
   }
 
   gfx::Size GetPrintCanvasSize() const;
 
   void FinishPrinting();
 
   bool IsLoadingSelection() {
     // It's not selection if not |owns_web_view_|.
     return owns_web_view_ && frame() && frame()->isLoading();
   }
 
  protected:
-  // WebKit::WebViewClient override:
+  // blink::WebViewClient override:
   virtual void didStopLoading();
 
   virtual void CallOnReady();
 
  private:
   void ResizeForPrinting();
   void RestoreSize();
   void CopySelection(const WebPreferences& preferences);
 
   base::WeakPtrFactory<PrepareFrameAndViewForPrint> weak_ptr_factory_;
 
   FrameReference frame_;
-  WebKit::WebNode node_to_print_;
+  blink::WebNode node_to_print_;
   bool owns_web_view_;
-  WebKit::WebPrintParams web_print_params_;
+  blink::WebPrintParams web_print_params_;
   gfx::Size prev_view_size_;
   gfx::Size prev_scroll_offset_;
   int expected_pages_count_;
   base::Closure on_ready_;
   bool should_print_backgrounds_;
   bool should_print_selection_only_;
   bool is_printing_started_;
 
   DISALLOW_COPY_AND_ASSIGN(PrepareFrameAndViewForPrint);
 };
 
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& params,
-    WebKit::WebFrame* frame,
-    const WebKit::WebNode& node,
+    blink::WebFrame* frame,
+    const blink::WebNode& node,
     bool ignore_css_margins)
     : weak_ptr_factory_(this),
       frame_(frame),
       node_to_print_(node),
       owns_web_view_(false),
       expected_pages_count_(0),
       should_print_backgrounds_(params.should_print_backgrounds),
       should_print_selection_only_(params.selection_only),
       is_printing_started_(false) {
   PrintMsg_Print_Params print_params = params;
   if (!should_print_selection_only_ ||
       !PrintingNodeOrPdfFrame(frame, node_to_print_)) {
     bool fit_to_page = ignore_css_margins &&
                        print_params.print_scaling_option ==
-                            WebKit::WebPrintScalingOptionFitToPrintableArea;
+                            blink::WebPrintScalingOptionFitToPrintableArea;
     ComputeWebKitPrintParamsInDesiredDpi(params, &web_print_params_);
     frame->printBegin(web_print_params_, node_to_print_);
     print_params = CalculatePrintParamsForCss(frame, 0, print_params,
                                               ignore_css_margins, fit_to_page,
                                               NULL);
     frame->printEnd();
   }
   ComputeWebKitPrintParamsInDesiredDpi(print_params, &web_print_params_);
 }
 
 PrepareFrameAndViewForPrint::~PrepareFrameAndViewForPrint() {
   FinishPrinting();
 }
 
 void PrepareFrameAndViewForPrint::ResizeForPrinting() {
   // 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));
 
   if (!frame())
     return;
-  WebKit::WebView* web_view = frame_.view();
+  blink::WebView* web_view = frame_.view();
   // Backup size and offset.
-  if (WebKit::WebFrame* web_frame = web_view->mainFrame())
+  if (blink::WebFrame* web_frame = web_view->mainFrame())
     prev_scroll_offset_ = web_frame->scrollOffset();
   prev_view_size_ = web_view->size();
 
   web_view->resize(print_layout_size);
 }
 
 
 void PrepareFrameAndViewForPrint::StartPrinting() {
   ResizeForPrinting();
-  WebKit::WebView* web_view = frame_.view();
+  blink::WebView* web_view = frame_.view();
   web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
   expected_pages_count_ =
       frame()->printBegin(web_print_params_, node_to_print_);
   is_printing_started_ = true;
 }
 
 void PrepareFrameAndViewForPrint::CopySelectionIfNeeded(
     const WebPreferences& preferences,
     const base::Closure& on_ready) {
   on_ready_ = on_ready;
@@ skipping 10 matching lines @@
   url_str.append(
       net::EscapeQueryParamValue(frame()->selectionAsMarkup().utf8(), false));
   RestoreSize();
   // 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).
   WebPreferences prefs = preferences;
   prefs.javascript_enabled = false;
   prefs.java_enabled = false;
 
-  WebKit::WebView* web_view = WebKit::WebView::create(this);
+  blink::WebView* web_view = blink::WebView::create(this);
   owns_web_view_ = true;
   content::ApplyWebPreferences(prefs, web_view);
   web_view->initializeMainFrame(this);
   frame_.Reset(web_view->mainFrame());
   node_to_print_.reset();
 
   // When loading is done this will call didStopLoading() and that will do the
   // actual printing.
-  frame()->loadRequest(WebKit::WebURLRequest(GURL(url_str)));
+  frame()->loadRequest(blink::WebURLRequest(GURL(url_str)));
 }
 
 void PrepareFrameAndViewForPrint::didStopLoading() {
   DCHECK(!on_ready_.is_null());
   // Don't call callback here, because it can delete |this| and WebView that is
   // called didStopLoading.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PrepareFrameAndViewForPrint::CallOnReady,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PrepareFrameAndViewForPrint::CallOnReady() {
   return on_ready_.Run();  // Can delete |this|.
 }
 
 gfx::Size PrepareFrameAndViewForPrint::GetPrintCanvasSize() const {
   DCHECK(is_printing_started_);
   return gfx::Size(web_print_params_.printContentArea.width,
                    web_print_params_.printContentArea.height);
 }
 
 void PrepareFrameAndViewForPrint::RestoreSize() {
   if (frame()) {
-    WebKit::WebView* web_view = frame_.GetFrame()->view();
+    blink::WebView* web_view = frame_.GetFrame()->view();
     web_view->resize(prev_view_size_);
-    if (WebKit::WebFrame* web_frame = web_view->mainFrame())
+    if (blink::WebFrame* web_frame = web_view->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
-  WebKit::WebFrame* frame = frame_.GetFrame();
+  blink::WebFrame* frame = frame_.GetFrame();
   if (frame) {
-    WebKit::WebView* web_view = frame->view();
+    blink::WebView* web_view = frame->view();
     if (is_printing_started_) {
       is_printing_started_ = false;
       frame->printEnd();
       if (!owns_web_view_) {
         web_view->settings()->setShouldPrintBackgrounds(false);
         RestoreSize();
       }
     }
     if (owns_web_view_) {
       DCHECK(!frame->isLoading());
@@ skipping 19 matching lines @@
       print_for_preview_(false),
       print_node_in_progress_(false),
       is_loading_(false),
       is_scripted_preview_delayed_(false),
       weak_ptr_factory_(this) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
-    WebKit::WebFrame* frame, bool user_initiated) {
+    blink::WebFrame* frame, bool user_initiated) {
 #if defined(OS_ANDROID)
   return false;
 #endif  // defined(OS_ANDROID)
   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;
 }
 
 void PrintWebViewHelper::DidStartLoading() {
   is_loading_ = true;
 }
 
 void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   ShowScriptedPrintPreview();
 }
 
 // Prints |frame| which called window.print().
-void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame,
+void PrintWebViewHelper::PrintPage(blink::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))
     return;
   IncrementScriptedPrintCount();
 
   if (is_preview_enabled_) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
   } else {
-    Print(frame, WebKit::WebNode());
+    Print(frame, blink::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 (prep_frame_view_)
     return;
 
   if (!render_view()->GetWebView())
     return;
-  WebKit::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (!main_frame)
     return;
 
-  WebKit::WebDocument document = main_frame->document();
+  blink::WebDocument document = main_frame->document();
   // <object> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview/print_preview.js
-  WebKit::WebElement pdf_element = document.getElementById("pdf-viewer");
+  blink::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.
   base::AutoReset<bool> set_printing_flag(&print_for_preview_, true);
 
-  WebKit::WebFrame* pdf_frame = pdf_element.document().frame();
+  blink::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
   // affects Windows only. On Linux and OSX RenderPagesForPrint does not use
   // printable_area. Also we can't change printable_area deeper inside
   // RenderPagesForPrint for Windows, because it's used also by native
   // printing and it expects real printable_area value.
   // See http://crbug.com/123408
   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(blink::WebFrame** frame) {
   DCHECK(frame);
-  WebKit::WebView* webView = render_view()->GetWebView();
+  blink::WebView* webView = render_view()->GetWebView();
   DCHECK(webView);
   if (!webView)
     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).
-  WebKit::WebFrame* focusedFrame = webView->focusedFrame();
+  blink::WebFrame* focusedFrame = webView->focusedFrame();
   *frame = focusedFrame->hasSelection() ? focusedFrame : webView->mainFrame();
   return true;
 }
 
 void PrintWebViewHelper::OnPrintPages() {
-  WebKit::WebFrame* frame;
+  blink::WebFrame* frame;
   if (GetPrintFrame(&frame))
-    Print(frame, WebKit::WebNode());
+    Print(frame, blink::WebNode());
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
-  WebKit::WebFrame* frame = print_preview_context_.source_frame();
+  blink::WebFrame* frame = print_preview_context_.source_frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
   Print(frame, print_preview_context_.source_node());
 }
 
 void PrintWebViewHelper::GetPageSizeAndContentAreaFromPageLayout(
     const PageSizeMargins& page_layout_in_points,
@@ skipping 21 matching lines @@
 }
 
 bool PrintWebViewHelper::IsPrintToPdfRequested(
     const base::DictionaryValue& job_settings) {
   bool print_to_pdf = false;
   if (!job_settings.GetBoolean(kSettingPrintToPDF, &print_to_pdf))
     NOTREACHED();
   return print_to_pdf;
 }
 
-WebKit::WebPrintScalingOption PrintWebViewHelper::GetPrintScalingOption(
+blink::WebPrintScalingOption PrintWebViewHelper::GetPrintScalingOption(
     bool source_is_html, const base::DictionaryValue& job_settings,
     const PrintMsg_Print_Params& params) {
   DCHECK(!print_for_preview_);
 
   if (params.print_to_pdf)
-    return WebKit::WebPrintScalingOptionSourceSize;
+    return blink::WebPrintScalingOptionSourceSize;
 
   if (!source_is_html) {
     if (!FitToPageEnabled(job_settings))
-      return WebKit::WebPrintScalingOptionNone;
+      return blink::WebPrintScalingOptionNone;
 
     bool no_plugin_scaling =
         print_preview_context_.source_frame()->isPrintScalingDisabledForPlugin(
             print_preview_context_.source_node());
 
     if (params.is_first_request && no_plugin_scaling)
-      return WebKit::WebPrintScalingOptionNone;
+      return blink::WebPrintScalingOptionNone;
   }
-  return WebKit::WebPrintScalingOptionFitToPrintableArea;
+  return blink::WebPrintScalingOptionFitToPrintableArea;
 }
 
 void PrintWebViewHelper::OnPrintPreview(const base::DictionaryValue& settings) {
   DCHECK(is_preview_enabled_);
   print_preview_context_.OnPrintPreview();
 
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PreviewEvent",
                             PREVIEW_EVENT_REQUESTED, PREVIEW_EVENT_MAX);
 
   if (!UpdatePrintSettings(print_preview_context_.source_frame(),
@@ skipping 185 matching lines @@
 void PrintWebViewHelper::SetScriptedPrintBlocked(bool blocked) {
   is_scripted_printing_blocked_ = blocked;
 }
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
   PrintNode(render_view()->GetContextMenuNode());
 }
 
 void PrintWebViewHelper::OnInitiatePrintPreview(bool selection_only) {
   DCHECK(is_preview_enabled_);
-  WebKit::WebFrame* frame = NULL;
+  blink::WebFrame* frame = NULL;
   GetPrintFrame(&frame);
   DCHECK(frame);
   print_preview_context_.InitWithFrame(frame);
   RequestPrintPreview(selection_only ?
                       PRINT_PREVIEW_USER_INITIATED_SELECTION :
                       PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME);
 }
 
 bool PrintWebViewHelper::IsPrintingEnabled() {
   bool result = false;
   Send(new PrintHostMsg_IsPrintingEnabled(routing_id(), &result));
   return result;
 }
 
-void PrintWebViewHelper::PrintNode(const WebKit::WebNode& node) {
+void PrintWebViewHelper::PrintNode(const blink::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;
   }
 
   if (print_node_in_progress_) {
     // This can happen as a result of processing sync messages when printing
     // from ppapi plugins. It's a rare case, so its OK to just fail here.
     // See http://crbug.com/159165.
     return;
   }
 
   print_node_in_progress_ = true;
 
   // 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 {
-    WebKit::WebNode duplicate_node(node);
+    blink::WebNode duplicate_node(node);
     Print(duplicate_node.document().frame(), duplicate_node);
   }
 
   print_node_in_progress_ = false;
 }
 
-void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
-                               const WebKit::WebNode& node) {
+void PrintWebViewHelper::Print(blink::WebFrame* frame,
+                               const blink::WebNode& node) {
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
 
   FrameReference frame_ref(frame);
 
   int expected_page_count = 0;
   if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
@@ skipping 98 matching lines @@
     LOG(ERROR) << "Printing failed.";
     return DidFinishPrinting(FAIL_PRINT);
   }
 }
 
 void PrintWebViewHelper::FinishFramePrinting() {
   prep_frame_view_.reset();
 }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
-bool PrintWebViewHelper::PrintPagesNative(WebKit::WebFrame* frame,
+bool PrintWebViewHelper::PrintPagesNative(blink::WebFrame* frame,
                                           int page_count,
                                           const gfx::Size& canvas_size) {
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
 
   PrintMsg_PrintPage_Params page_params;
   page_params.params = print_params;
   if (params.pages.empty()) {
     for (int i = 0; i < page_count; ++i) {
       page_params.page_number = i;
       PrintPageInternal(page_params, canvas_size, frame);
     }
   } else {
     for (size_t i = 0; i < params.pages.size(); ++i) {
       if (params.pages[i] >= page_count)
         break;
       page_params.page_number = params.pages[i];
       PrintPageInternal(page_params, canvas_size, frame);
     }
   }
   return true;
 }
 
 #endif  // OS_MACOSX || OS_WIN
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::ComputePageLayoutInPointsForCss(
-    WebKit::WebFrame* frame,
+    blink::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params,
     bool ignore_css_margins,
     double* scale_factor,
     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,
+          blink::WebPrintScalingOptionFitToPrintableArea,
       scale_factor);
   CalculatePageLayoutFromPrintParams(params, page_layout_in_points);
 }
 
 bool PrintWebViewHelper::InitPrintSettings(bool fit_to_paper_size) {
   PrintMsg_PrintPages_Params settings;
   Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
                                                 &settings.params));
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
   // terminate.
   bool result = true;
   if (!PrintMsg_Print_Params_IsValid(settings.params))
     result = false;
 
   if (result &&
       (settings.params.dpi < kMinDpi || settings.params.document_cookie == 0)) {
     // Invalid print page settings.
     NOTREACHED();
     result = false;
   }
 
   // Reset to default values.
   ignore_css_margins_ = false;
   settings.pages.clear();
 
   settings.params.print_scaling_option =
-      WebKit::WebPrintScalingOptionSourceSize;
+      blink::WebPrintScalingOptionSourceSize;
   if (fit_to_paper_size) {
     settings.params.print_scaling_option =
-        WebKit::WebPrintScalingOptionFitToPrintableArea;
+        blink::WebPrintScalingOptionFitToPrintableArea;
   }
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   return result;
 }
 
-bool PrintWebViewHelper::CalculateNumberOfPages(WebKit::WebFrame* frame,
-                                                const WebKit::WebNode& node,
+bool PrintWebViewHelper::CalculateNumberOfPages(blink::WebFrame* frame,
+                                                const blink::WebNode& node,
                                                 int* number_of_pages) {
   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;
   }
 
   const PrintMsg_Print_Params& params = print_pages_params_->params;
   PrepareFrameAndViewForPrint prepare(params, frame, node, ignore_css_margins_);
   prepare.StartPrinting();
 
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              params.document_cookie));
   *number_of_pages = prepare.GetExpectedPageCount();
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
-    WebKit::WebFrame* frame,
-    const WebKit::WebNode& node,
+    blink::WebFrame* frame,
+    const blink::WebNode& node,
     const base::DictionaryValue& passed_job_settings) {
   DCHECK(is_preview_enabled_);
   const base::DictionaryValue* job_settings = &passed_job_settings;
   base::DictionaryValue modified_job_settings;
   if (job_settings->empty()) {
     if (!print_for_preview_)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
@@ skipping 20 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;
+      blink::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 39 matching lines @@
     }
   }
 
   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(blink::WebFrame* frame,
+                                                  const blink::WebNode& node,
                                                   int expected_pages_count) {
   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;
   MarginType margin_type = DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
     margin_type = GetMarginsForPdf(frame, node);
   params.margin_type = margin_type;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
   // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
   // value before and restore it afterwards.
-  WebKit::WebPrintScalingOption scaling_option =
+  blink::WebPrintScalingOption scaling_option =
       print_pages_params_->params.print_scaling_option;
 
   print_pages_params_.reset();
   IPC::SyncMessage* msg =
       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) {
+bool PrintWebViewHelper::RenderPagesForPrint(blink::WebFrame* frame,
+                                             const blink::WebNode& node) {
   if (!frame || prep_frame_view_)
     return false;
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   prep_frame_view_.reset(
       new PrepareFrameAndViewForPrint(print_params, frame, node,
                                       ignore_css_margins_));
   DCHECK(!print_pages_params_->params.selection_only ||
          print_pages_params_->pages.empty());
   prep_frame_view_->CopySelectionIfNeeded(
@@ skipping 19 matching lines @@
                                 shared_mem_handle);
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 #endif  // defined(OS_POSIX)
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintTooFrequent(
-    WebKit::WebFrame* frame) {
+    blink::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;
 
-  WebKit::WebString message(
-      WebKit::WebString::fromUTF8("Ignoring too frequent calls to print()."));
+  blink::WebString message(
+      blink::WebString::fromUTF8("Ignoring too frequent calls to print()."));
   frame->addMessageToConsole(
-      WebKit::WebConsoleMessage(
-          WebKit::WebConsoleMessage::LevelWarning, message));
+      blink::WebConsoleMessage(
+          blink::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 117 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) {
+    blink::WebFrame* web_frame) {
   DCHECK(web_frame);
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   source_frame_.Reset(web_frame);
   source_node_.reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
-    const WebKit::WebNode& web_node) {
+    const blink::WebNode& web_node) {
   DCHECK(!web_node.isNull());
   DCHECK(web_node.document().frame());
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   source_frame_.Reset(web_node.document().frame());
   source_node_ = web_node;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
@@ skipping 146 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::source_frame() {
+blink::WebFrame* PrintWebViewHelper::PrintPreviewContext::source_frame() {
   DCHECK(state_ != UNINITIALIZED);
   return source_frame_.GetFrame();
 }
 
-const WebKit::WebNode&
+const blink::WebNode&
     PrintWebViewHelper::PrintPreviewContext::source_node() const {
   DCHECK(state_ != UNINITIALIZED);
   return source_node_;
 }
 
-WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::prepared_frame() {
+blink::WebFrame* PrintWebViewHelper::PrintPreviewContext::prepared_frame() {
   DCHECK(state_ != UNINITIALIZED);
   return prep_frame_view_->frame();
 }
 
-const WebKit::WebNode&
+const blink::WebNode&
     PrintWebViewHelper::PrintPreviewContext::prepared_node() const {
   DCHECK(state_ != UNINITIALIZED);
   return prep_frame_view_->node();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
   DCHECK(state_ != UNINITIALIZED);
   return total_page_count_;
 }
 
@@ skipping 16 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
 }  // namespace printing