Style fixes.

components/printing/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 "components/printing/renderer/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/json/json_writer.h"
@@ skipping 126 matching lines @@
   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(
-      ConvertUnit(new_content_width, kPixelsPerInch, dpi),
-      ConvertUnit(new_content_height, kPixelsPerInch, dpi));
+  page_css_params.content_size =
+      gfx::Size(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(
-        ConvertUnit(page_size_in_pixels.width, kPixelsPerInch, dpi),
-        ConvertUnit(page_size_in_pixels.height, kPixelsPerInch, dpi));
+    page_css_params.page_size =
+        gfx::Size(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 =
       ConvertUnit(margin_top_in_pixels, kPixelsPerInch, dpi);
   page_css_params.margin_left =
@@ skipping 25 matching lines @@
     scale_factor = ratio_width < ratio_height ? ratio_width : ratio_height;
     content_width *= scale_factor;
     content_height *= scale_factor;
   }
   params_to_fit->margin_top = static_cast<int>(
       (default_page_size_height - css_page_size_height * scale_factor) / 2 +
       (params_to_fit->margin_top * scale_factor));
   params_to_fit->margin_left = static_cast<int>(
       (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->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) {
   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;
+  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, 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 =
@@ skipping 19 matching lines @@
                 page_params->printable_area.width()));
 }
 
 void ComputeWebKitPrintParamsInDesiredDpi(
     const PrintMsg_Print_Params& 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);
+  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->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);
+  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);
 }
 
 blink::WebPlugin* GetPlugin(const blink::WebFrame* frame) {
-  return frame->document().isPluginDocument() ?
-         frame->document().to<blink::WebPluginDocument>().plugin() : NULL;
+  return frame->document().isPluginDocument()
+             ? frame->document().to<blink::WebPluginDocument>().plugin()
+             : NULL;
 }
 
 bool PrintingNodeOrPdfFrame(const blink::WebFrame* frame,
                             const blink::WebNode& node) {
   if (!node.isNull())
     return true;
   blink::WebPlugin* plugin = GetPlugin(frame);
   return plugin && plugin->supportsPaginatedPrint();
 }
 
@@ skipping 62 matching lines @@
   return blink::WebPrintScalingOptionFitToPrintableArea;
 }
 
 PrintMsg_Print_Params CalculatePrintParamsForCss(
     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 css_params =
+      GetCssPrintParams(frame, page_index, page_params);
 
   PrintMsg_Print_Params params = page_params;
   EnsureOrientationMatches(css_params, &params);
 
   if (ignore_css_margins && fit_to_page)
     return params;
 
   PrintMsg_Print_Params result_params = css_params;
   if (ignore_css_margins) {
     result_params.margin_top = params.margin_top;
     result_params.margin_left = params.margin_left;
 
     DCHECK(!fit_to_page);
     // Since we are ignoring the margins, the css page size is no longer
     // valid.
     int default_margin_right = params.page_size.width() -
-        params.content_size.width() - params.margin_left;
+                               params.content_size.width() - params.margin_left;
     int default_margin_bottom = params.page_size.height() -
-        params.content_size.height() - params.margin_top;
-    result_params.content_size = gfx::Size(
-        result_params.page_size.width() - result_params.margin_left -
-            default_margin_right,
-        result_params.page_size.height() - result_params.margin_top -
-            default_margin_bottom);
+                                params.content_size.height() -
+                                params.margin_top;
+    result_params.content_size =
+        gfx::Size(result_params.page_size.width() - result_params.margin_left -
+                      default_margin_right,
+                  result_params.page_size.height() - result_params.margin_top -
+                      default_margin_bottom);
   }
 
   if (fit_to_page) {
     double factor = FitPrintParamsToPage(params, &result_params);
     if (scale_factor)
       *scale_factor = factor;
   }
   return result_params;
 }
 
@@ skipping 17 matching lines @@
   } else {
     view_ = NULL;
     frame_ = NULL;
   }
 }
 
 blink::WebLocalFrame* FrameReference::GetFrame() {
   if (view_ == NULL || frame_ == NULL)
     return NULL;
   for (blink::WebFrame* frame = view_->mainFrame(); frame != NULL;
-           frame = frame->traverseNext(false)) {
+       frame = frame->traverseNext(false)) {
     if (frame == frame_)
       return frame_;
   }
   return NULL;
 }
 
 blink::WebView* FrameReference::view() {
   return view_;
 }
 
@@ skipping 81 matching lines @@
   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();
 
-  blink::WebLocalFrame* frame() {
-    return frame_.GetFrame();
-  }
+  blink::WebLocalFrame* frame() { return frame_.GetFrame(); }
 
-  const blink::WebNode& node() const {
-    return node_to_print_;
-  }
+  const blink::WebNode& node() const { return node_to_print_; }
 
-  int GetExpectedPageCount() const {
-    return expected_pages_count_;
-  }
+  int GetExpectedPageCount() const { return expected_pages_count_; }
 
   void FinishPrinting();
 
   bool IsLoadingSelection() {
     // It's not selection if not |owns_web_view_|.
     return owns_web_view_ && frame() && frame()->isLoading();
   }
 
   // TODO(ojan): Remove this override and have this class use a non-null
   // layerTreeView.
@@ skipping 45 matching lines @@
       expected_pages_count_(0),
       should_print_backgrounds_(params.should_print_backgrounds),
       should_print_selection_only_(params.selection_only),
       is_printing_started_(false),
       weak_ptr_factory_(this) {
   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 ==
-                            blink::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);
+    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() {
@@ skipping 11 matching lines @@
     return;
   blink::WebView* web_view = frame_.view();
   // Backup size and offset.
   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();
   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(
@@ skipping 36 matching lines @@
 
 bool PrepareFrameAndViewForPrint::allowsBrokenNullLayerTreeView() const {
   return true;
 }
 
 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()));
+      FROM_HERE, base::Bind(&PrepareFrameAndViewForPrint::CallOnReady,
+                            weak_ptr_factory_.GetWeakPtr()));
 }
 
 blink::WebFrame* PrepareFrameAndViewForPrint::createChildFrame(
     blink::WebLocalFrame* parent,
     const blink::WebString& name,
     blink::WebSandboxFlags sandboxFlags) {
   blink::WebFrame* frame = blink::WebLocalFrame::create(this);
   parent->appendChild(frame);
   return frame;
 }
@@ skipping 40 matching lines @@
 }
 
 bool PrintWebViewHelper::Delegate::IsAskPrintSettingsEnabled() {
   return true;
 }
 
 bool PrintWebViewHelper::Delegate::IsScriptedPrintEnabled() {
   return true;
 }
 
-PrintWebViewHelper::PrintWebViewHelper(
-    content::RenderView* render_view,
-    scoped_ptr<Delegate> delegate)
+PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view,
+                                       scoped_ptr<Delegate> delegate)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       reset_prep_frame_view_(false),
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
       is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false),
       delegate_(delegate.Pass()),
       print_node_in_progress_(false),
       is_loading_(false),
       is_scripted_preview_delayed_(false),
       weak_ptr_factory_(this) {
   if (!delegate_->IsPrintPreviewEnabled())
     DisablePreview();
 }
 
-PrintWebViewHelper::~PrintWebViewHelper() {}
+PrintWebViewHelper::~PrintWebViewHelper() {
+}
 
 // static
 void PrintWebViewHelper::DisablePreview() {
   g_is_preview_enabled_ = false;
 }
 
-bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
-    blink::WebFrame* frame, bool user_initiated) {
+bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(blink::WebFrame* frame,
+                                                       bool user_initiated) {
   if (!delegate_->IsScriptedPrintEnabled())
     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.
   return !is_scripted_printing_blocked_ &&
          (user_initiated || g_is_preview_enabled_ ||
           scripting_throttler_.IsAllowed(frame));
@@ skipping 72 matching lines @@
     NOTREACHED();
     return;
   }
 
   // The out-of-process plugin element is nested within a frame. In tests, there
   // may not be an iframe containing the out-of-process plugin, so continue with
   // the element with ID "pdf-viewer" if it isn't an iframe.
   blink::WebLocalFrame* plugin_frame = pdf_element.document().frame();
   blink::WebElement plugin_element = pdf_element;
   if (delegate_->IsOutOfProcessPdfEnabled() &&
-        pdf_element.hasHTMLTagName("iframe")) {
+      pdf_element.hasHTMLTagName("iframe")) {
     plugin_frame = blink::WebLocalFrame::fromFrameOwnerElement(pdf_element);
     plugin_element = delegate_->GetPdfElement(plugin_frame);
     if (plugin_element.isNull()) {
       NOTREACHED();
       return;
     }
   }
 
   // Set |print_for_preview_| flag and autoreset it to back to original
   // on return.
@@ skipping 60 matching lines @@
   }
   Print(frame, print_preview_context_.source_node(), false);
 }
 #endif  // ENABLE_BASIC_PRINTING
 
 void PrintWebViewHelper::GetPageSizeAndContentAreaFromPageLayout(
     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.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.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 base::DictionaryValue& settings) {
   int margins_type = 0;
@@ skipping 18 matching lines @@
 
   if (!print_preview_context_.source_frame()) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!UpdatePrintSettings(print_preview_context_.source_frame(),
                            print_preview_context_.source_node(), settings)) {
     if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
       Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
-          routing_id(),
-          print_pages_params_ ?
-              print_pages_params_->params.document_cookie : 0));
+          routing_id(), print_pages_params_
+                            ? print_pages_params_->params.document_cookie
+                            : 0));
       notify_browser_of_print_failure_ = false;  // Already sent.
     }
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   // Set the options from document if we are previewing a pdf and send a
   // message to browser.
   if (print_pages_params_->params.is_first_request &&
       !print_preview_context_.IsModifiable()) {
     PrintHostMsg_SetOptionsFromDocument_Params params;
     SetOptionsFromDocument(params);
     Send(new PrintHostMsg_SetOptionsFromDocument(routing_id(), params));
   }
 
   is_print_ready_metafile_sent_ = false;
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
 
   bool generate_draft_pages = false;
-  if (!settings.GetBoolean(kSettingGenerateDraftData,
-                           &generate_draft_pages)) {
+  if (!settings.GetBoolean(kSettingGenerateDraftData, &generate_draft_pages)) {
     NOTREACHED();
   }
   print_preview_context_.set_generate_draft_pages(generate_draft_pages);
 
   PrepareFrameForPreviewDocument();
 }
 
 void PrintWebViewHelper::PrepareFrameForPreviewDocument() {
   reset_prep_frame_view_ = false;
 
   if (!print_pages_params_ || CheckForCancel()) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   // Don't reset loading frame or WebKit will fail assert. Just retry when
   // current selection is loaded.
   if (prep_frame_view_ && prep_frame_view_->IsLoadingSelection()) {
     reset_prep_frame_view_ = true;
     return;
   }
 
   const PrintMsg_Print_Params& print_params = print_pages_params_->params;
-  prep_frame_view_.reset(
-      new PrepareFrameAndViewForPrint(print_params,
-                                      print_preview_context_.source_frame(),
-                                      print_preview_context_.source_node(),
-                                      ignore_css_margins_));
+  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
+      print_params, print_preview_context_.source_frame(),
+      print_preview_context_.source_node(), ignore_css_margins_));
   prep_frame_view_->CopySelectionIfNeeded(
       render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPreviewDocument,
                  base::Unretained(this)));
 }
 
 void PrintWebViewHelper::OnFramePreparedForPreviewDocument() {
   if (reset_prep_frame_view_) {
     PrepareFrameForPreviewDocument();
     return;
@@ skipping 14 matching lines @@
   if (!print_preview_context_.CreatePreviewDocument(prep_frame_view_.release(),
                                                     pages)) {
     return false;
   }
 
   PageSizeMargins default_page_layout;
   ComputePageLayoutInPointsForCss(print_preview_context_.prepared_frame(), 0,
                                   print_params, ignore_css_margins_, NULL,
                                   &default_page_layout);
 
-  bool has_page_size_style = PrintingFrameHasPageSizeStyle(
-      print_preview_context_.prepared_frame(),
-      print_preview_context_.total_page_count());
+  bool has_page_size_style =
+      PrintingFrameHasPageSizeStyle(print_preview_context_.prepared_frame(),
+                                    print_preview_context_.total_page_count());
   int dpi = GetDPI(&print_params);
 
   gfx::Rect printable_area_in_points(
       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(),
@@ skipping 88 matching lines @@
   GetPrintFrame(&frame);
   DCHECK(frame);
   // If we are printing a PDF extension frame, find the plugin node and print
   // that instead.
   auto plugin = delegate_->GetPdfElement(frame);
   if (!plugin.isNull()) {
     PrintNode(plugin);
     return;
   }
   print_preview_context_.InitWithFrame(frame);
-  RequestPrintPreview(selection_only ?
-                      PRINT_PREVIEW_USER_INITIATED_SELECTION :
-                      PRINT_PREVIEW_USER_INITIATED_ENTIRE_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 blink::WebNode& node) {
   if (node.isNull() || !node.document().frame()) {
@@ skipping 40 matching lines @@
   }
 
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (delegate_->IsAskPrintSettingsEnabled() &&
-      !GetPrintSettingsFromUser(frame_ref.GetFrame(), node,
-                                expected_page_count,
+      !GetPrintSettingsFromUser(frame_ref.GetFrame(), node, expected_page_count,
                                 is_scripted)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame_ref.GetFrame(), node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
@@ skipping 10 matching lines @@
       break;
 
     case FAIL_PRINT:
       if (notify_browser_of_print_failure_ && print_pages_params_) {
         int cookie = print_pages_params_->params.document_cookie;
         Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
       }
       break;
 
     case FAIL_PREVIEW:
-      int cookie = print_pages_params_ ?
-          print_pages_params_->params.document_cookie : 0;
+      int cookie =
+          print_pages_params_ ? print_pages_params_->params.document_cookie : 0;
       if (notify_browser_of_print_failure_) {
         LOG(ERROR) << "CreatePreviewDocument failed";
         Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
       } else {
         Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
       }
       print_preview_context_.Failed(notify_browser_of_print_failure_);
       break;
   }
   prep_frame_view_.reset();
@@ skipping 32 matching lines @@
     // Printing for system dialog.
     int printed_count = params.pages.empty() ? page_count : params.pages.size();
 #if !defined(OS_CHROMEOS)
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.SystemDialog", printed_count);
 #else
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToCloudPrintWebDialog",
                          printed_count);
 #endif  // !defined(OS_CHROMEOS)
   }
 
-
   if (!PrintPagesNative(prep_frame_view_->frame(), page_count)) {
     LOG(ERROR) << "Printing failed.";
     return DidFinishPrinting(FAIL_PRINT);
   }
 }
 
 void PrintWebViewHelper::FinishFramePrinting() {
   prep_frame_view_.reset();
 }
 
@@ skipping 47 matching lines @@
   // 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;
 
   // Reset to default values.
   ignore_css_margins_ = false;
   settings.pages.clear();
 
-  settings.params.print_scaling_option =
-      blink::WebPrintScalingOptionSourceSize;
+  settings.params.print_scaling_option = blink::WebPrintScalingOptionSourceSize;
   if (fit_to_paper_size) {
     settings.params.print_scaling_option =
         blink::WebPrintScalingOptionFitToPrintableArea;
   }
 
   SetPrintPagesParams(settings);
   return result;
 }
 
 bool PrintWebViewHelper::CalculateNumberOfPages(blink::WebLocalFrame* frame,
@@ skipping 53 matching lines @@
 
   if (print_for_preview_ || !source_is_html) {
     modified_job_settings.MergeDictionary(job_settings);
     modified_job_settings.SetBoolean(kSettingHeaderFooterEnabled, false);
     modified_job_settings.SetInteger(kSettingMarginsType, NO_MARGINS);
     job_settings = &modified_job_settings;
   }
 
   // Send the cookie so that UpdatePrintSettings can reuse PrinterQuery when
   // possible.
-  int cookie = print_pages_params_ ?
-      print_pages_params_->params.document_cookie : 0;
+  int cookie =
+      print_pages_params_ ? print_pages_params_->params.document_cookie : 0;
   PrintMsg_PrintPages_Params settings;
   bool canceled = false;
-  Send(new PrintHostMsg_UpdatePrintSettings(
-      routing_id(), cookie, *job_settings, &settings, &canceled));
+  Send(new PrintHostMsg_UpdatePrintSettings(routing_id(), cookie, *job_settings,
+                                            &settings, &canceled));
   if (canceled) {
     notify_browser_of_print_failure_ = false;
     return false;
   }
 
   if (!job_settings->GetInteger(kPreviewUIID, &settings.params.preview_ui_id)) {
     NOTREACHED();
     print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
@@ skipping 78 matching lines @@
                  base::Unretained(this)));
   return true;
 }
 
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     PdfMetafileSkia* metafile,
     base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   scoped_ptr<base::SharedMemory> shared_buf(
-      content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(
-          buf_size).release());
+      content::RenderThread::Get()
+          ->HostAllocateSharedMemoryBuffer(buf_size)
+          .release());
 
   if (shared_buf) {
     if (shared_buf->Map(buf_size)) {
       metafile->GetData(shared_buf->memory(), buf_size);
       return shared_buf->GiveToProcess(base::GetCurrentProcessHandle(),
                                        shared_mem_handle);
     }
   }
   return false;
 }
 #endif  // defined(OS_POSIX)
 
 void PrintWebViewHelper::ShowScriptedPrintPreview() {
   if (is_scripted_preview_delayed_) {
     is_scripted_preview_delayed_ = false;
-    Send(new PrintHostMsg_ShowScriptedPrintPreview(routing_id(),
-            print_preview_context_.IsModifiable()));
+    Send(new PrintHostMsg_ShowScriptedPrintPreview(
+        routing_id(), print_preview_context_.IsModifiable()));
   }
 }
 
 void PrintWebViewHelper::RequestPrintPreview(PrintPreviewRequestType type) {
   const bool is_modifiable = print_preview_context_.IsModifiable();
   const bool has_selection = print_preview_context_.HasSelection();
   PrintHostMsg_RequestPrintPreview_Params params;
   params.is_modifiable = is_modifiable;
   params.has_selection = has_selection;
   switch (type) {
     case PRINT_PREVIEW_SCRIPTED: {
       // Shows scripted print preview in two stages.
       // 1. PrintHostMsg_SetupScriptedPrintPreview blocks this call and JS by
       //    pumping messages here.
       // 2. PrintHostMsg_ShowScriptedPrintPreview shows preview once the
       //    document has been loaded.
       is_scripted_preview_delayed_ = true;
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         // Wait for DidStopLoading. Plugins may not know the correct
         // |is_modifiable| value until they are fully loaded, which occurs when
         // DidStopLoading() is called. Defer showing the preview until then.
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
                        base::Unretained(this));
       } else {
         base::MessageLoop::current()->PostTask(
-            FROM_HERE,
-            base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
-                       weak_ptr_factory_.GetWeakPtr()));
+            FROM_HERE, base::Bind(&PrintWebViewHelper::ShowScriptedPrintPreview,
+                                  weak_ptr_factory_.GetWeakPtr()));
       }
       IPC::SyncMessage* msg =
           new PrintHostMsg_SetupScriptedPrintPreview(routing_id());
       msg->EnableMessagePumping();
       Send(msg);
       is_scripted_preview_delayed_ = false;
       return;
     }
     case PRINT_PREVIEW_USER_INITIATED_ENTIRE_FRAME: {
       // Wait for DidStopLoading. Continuing with this function while
       // |is_loading_| is true will cause print preview to hang when try to
       // print a PDF document.
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::RequestPrintPreview,
-                       base::Unretained(this),
-                       type);
+                       base::Unretained(this), type);
         return;
       }
 
       break;
     }
     case PRINT_PREVIEW_USER_INITIATED_SELECTION: {
       DCHECK(has_selection);
       DCHECK(!GetPlugin(print_preview_context_.source_frame()));
       params.selection_only = has_selection;
       break;
     }
     case PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE: {
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         on_stop_loading_closure_ =
             base::Bind(&PrintWebViewHelper::RequestPrintPreview,
-                       base::Unretained(this),
-                       type);
+                       base::Unretained(this), type);
         return;
       }
 
       params.webnode_only = true;
       break;
     }
     default: {
       NOTREACHED();
       return;
     }
@@ skipping 31 matching lines @@
     print_preview_context_.set_error(
         PREVIEW_ERROR_PAGE_RENDERED_WITHOUT_METAFILE);
     return false;
   }
 
   PrintHostMsg_DidPreviewPage_Params preview_page_params;
   // Get the size of the resulting metafile.
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 0u);
   if (!CopyMetafileDataToSharedMem(
-      metafile, &(preview_page_params.metafile_data_handle))) {
+          metafile, &(preview_page_params.metafile_data_handle))) {
     LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_FAILED);
     return false;
   }
   preview_page_params.data_size = buf_size;
   preview_page_params.page_number = page_number;
   preview_page_params.preview_request_id =
       print_pages_params_->params.preview_request_id;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
@@ skipping 57 matching lines @@
   if (!metafile_->Init()) {
     set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
     LOG(ERROR) << "PdfMetafileSkia Init failed";
     return false;
   }
 
   current_page_index_ = 0;
   pages_to_render_ = pages;
   // Sort and make unique.
   std::sort(pages_to_render_.begin(), pages_to_render_.end());
-  pages_to_render_.resize(std::unique(pages_to_render_.begin(),
-                                      pages_to_render_.end()) -
-                          pages_to_render_.begin());
+  pages_to_render_.resize(
+      std::unique(pages_to_render_.begin(), pages_to_render_.end()) -
+      pages_to_render_.begin());
   // Remove invalid pages.
   pages_to_render_.resize(std::lower_bound(pages_to_render_.begin(),
                                            pages_to_render_.end(),
                                            total_page_count_) -
                           pages_to_render_.begin());
   print_ready_metafile_page_count_ = pages_to_render_.size();
   if (pages_to_render_.empty()) {
     print_ready_metafile_page_count_ = total_page_count_;
     // Render all pages.
     for (int i = 0; i < total_page_count_; ++i)
@@ skipping 35 matching lines @@
   base::TimeTicks begin_time = base::TimeTicks::Now();
   metafile_->FinishDocument();
 
   if (print_ready_metafile_page_count_ <= 0) {
     NOTREACHED();
     return;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
                              document_render_time_);
-  base::TimeDelta total_time = (base::TimeTicks::Now() - begin_time) +
-                               document_render_time_;
+  base::TimeDelta total_time =
+      (base::TimeTicks::Now() - begin_time) + document_render_time_;
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTime",
                              total_time);
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
                              total_time / pages_to_render_.size());
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Finished() {
   DCHECK_EQ(DONE, state_);
   state_ = INITIALIZED;
   ClearContext();
@@ skipping 29 matching lines @@
 bool PrintWebViewHelper::PrintPreviewContext::HasSelection() {
   return IsModifiable() && source_frame()->hasSelection();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
     const {
   DCHECK(IsRendering());
   return current_page_index_ == print_ready_metafile_page_count_;
 }
 
-bool  PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
+bool PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
   DCHECK(IsRendering());
   return static_cast<size_t>(current_page_index_) == pages_to_render_.size();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_generate_draft_pages(
     bool generate_draft_pages) {
   DCHECK_EQ(INITIALIZED, state_);
   generate_draft_pages_ = generate_draft_pages;
 }
 
@@ skipping 96 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing