Clang format pdf/

pdf/out_of_process_instance.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 "pdf/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
-#include <algorithm>  // for min/max()
+#include <algorithm>       // for min/max()
 #define _USE_MATH_DEFINES  // for M_PI
-#include <cmath>      // for log() and pow()
 #include <math.h>
+#include <cmath>  // for log() and pow()
 #include <list>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/content_restriction.h"
@@ skipping 146 matching lines @@
   pp::Var var;
   void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
   if (object) {
     var = static_cast<OutOfProcessInstance*>(object)->GetLinkAtPosition(
         pp::Point(point));
   }
   return var.Detach();
 }
 
 void Transform(PP_Instance instance, PP_PrivatePageTransformType type) {
-  void* object =
-      pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
+  void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
   if (object) {
     OutOfProcessInstance* obj_instance =
         static_cast<OutOfProcessInstance*>(object);
     switch (type) {
       case PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW:
         obj_instance->RotateClockwise();
         break;
       case PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW:
         obj_instance->RotateCounterclockwise();
         break;
@@ skipping 16 matching lines @@
 void EnableAccessibility(PP_Instance instance) {
   void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
   if (object) {
     OutOfProcessInstance* obj_instance =
         static_cast<OutOfProcessInstance*>(object);
     return obj_instance->EnableAccessibility();
   }
 }
 
 const PPP_Pdf ppp_private = {
-  &GetLinkAtPosition,
-  &Transform,
-  &GetPrintPresetOptionsFromDocument,
-  &EnableAccessibility,
+    &GetLinkAtPosition, &Transform, &GetPrintPresetOptionsFromDocument,
+    &EnableAccessibility,
 };
 
 int ExtractPrintPreviewPageIndex(const std::string& src_url) {
   // Sample |src_url| format: chrome://print/id/page_index/print.pdf
-  std::vector<std::string> url_substr = base::SplitString(
-      src_url.substr(strlen(kChromePrint)), "/",
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> url_substr =
+      base::SplitString(src_url.substr(strlen(kChromePrint)), "/",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (url_substr.size() != 3)
     return -1;
 
   if (url_substr[2] != "print.pdf")
     return -1;
 
   int page_index = 0;
   if (!base::StringToInt(url_substr[1], &page_index))
     return -1;
   return page_index;
@@ skipping 21 matching lines @@
 // replace this with a custom PPB_PDF function.
 pp::Var ModalDialog(const pp::Instance* instance,
                     const std::string& type,
                     const std::string& message,
                     const std::string& default_answer) {
   const PPB_Instance_Private* interface =
       reinterpret_cast<const PPB_Instance_Private*>(
           pp::Module::Get()->GetBrowserInterface(
               PPB_INSTANCE_PRIVATE_INTERFACE));
   pp::VarPrivate window(pp::PASS_REF,
-      interface->GetWindowObject(instance->pp_instance()));
+                        interface->GetWindowObject(instance->pp_instance()));
   if (default_answer.empty())
     return window.Call(type, message);
   return window.Call(type, message, default_answer);
 }
 
 }  // namespace
 
 OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
     : pp::Instance(instance),
       pp::Find_Private(this),
@@ skipping 46 matching lines @@
                                 const char* argv[]) {
   // Check if the PDF is being loaded in the PDF chrome extension. We only allow
   // the plugin to be loaded in the extension and print preview to avoid
   // exposing sensitive APIs directly to external websites.
   pp::Var document_url_var = pp::URLUtil_Dev::Get()->GetDocumentURL(this);
   if (!document_url_var.is_string())
     return false;
   std::string document_url = document_url_var.AsString();
   base::StringPiece document_url_piece(document_url);
   is_print_preview_ = document_url_piece.starts_with(kChromePrint);
-  if (!document_url_piece.starts_with(kChromeExtension) &&
-      !is_print_preview_) {
+  if (!document_url_piece.starts_with(kChromeExtension) && !is_print_preview_) {
     return false;
   }
 
   // Check if the plugin is full frame. This is passed in from JS.
   for (uint32_t i = 0; i < argc; ++i) {
     if (strcmp(argn[i], "full-frame") == 0) {
       full_ = true;
       break;
     }
   }
@@ skipping 48 matching lines @@
 
 void OutOfProcessInstance::HandleMessage(const pp::Var& message) {
   pp::VarDictionary dict(message);
   if (!dict.Get(kType).is_string()) {
     NOTREACHED();
     return;
   }
 
   std::string type = dict.Get(kType).AsString();
 
-  if (type == kJSViewportType &&
-      dict.Get(pp::Var(kJSXOffset)).is_number() &&
+  if (type == kJSViewportType && dict.Get(pp::Var(kJSXOffset)).is_number() &&
       dict.Get(pp::Var(kJSYOffset)).is_number() &&
       dict.Get(pp::Var(kJSZoom)).is_number() &&
       dict.Get(pp::Var(kJSPinchPhase)).is_number()) {
     received_viewport_message_ = true;
     stop_scrolling_ = false;
     PinchPhase pinch_phase =
         static_cast<PinchPhase>(dict.Get(pp::Var(kJSPinchPhase)).AsInt());
     double zoom = dict.Get(pp::Var(kJSZoom)).AsDouble();
     double zoom_ratio = zoom / zoom_;
 
@@ skipping 40 matching lines @@
         // We want to keep the paint in the middle but it must stay in the same
         // position relative to the scroll bars.
         paint_offset = pp::Point(0, (1 - zoom_ratio) * pinch_center.y());
         scroll_delta =
             pp::Point(0, (scroll_offset.y() -
                           scroll_offset_at_last_raster_.y() * zoom_ratio));
 
         pinch_vector = pp::Point();
         last_bitmap_smaller_ = true;
       } else if (last_bitmap_smaller_) {
-          pinch_center = pp::Point((plugin_size_.width() / device_scale_) / 2,
-              (plugin_size_.height() / device_scale_) / 2);
-          const double zoom_when_doc_covers_plugin_width =
-              zoom_ * plugin_size_.width() / GetDocumentPixelWidth();
-          paint_offset = pp::Point(
-              (1 - zoom / zoom_when_doc_covers_plugin_width) * pinch_center.x(),
-              (1 - zoom_ratio) * pinch_center.y());
-          pinch_vector = pp::Point();
-          scroll_delta =
-              pp::Point((scroll_offset.x() -
-                         scroll_offset_at_last_raster_.x() * zoom_ratio),
-                        (scroll_offset.y() -
-                         scroll_offset_at_last_raster_.y() * zoom_ratio));
+        pinch_center = pp::Point((plugin_size_.width() / device_scale_) / 2,
+                                 (plugin_size_.height() / device_scale_) / 2);
+        const double zoom_when_doc_covers_plugin_width =
+            zoom_ * plugin_size_.width() / GetDocumentPixelWidth();
+        paint_offset = pp::Point(
+            (1 - zoom / zoom_when_doc_covers_plugin_width) * pinch_center.x(),
+            (1 - zoom_ratio) * pinch_center.y());
+        pinch_vector = pp::Point();
+        scroll_delta =
+            pp::Point((scroll_offset.x() -
+                       scroll_offset_at_last_raster_.x() * zoom_ratio),
+                      (scroll_offset.y() -
+                       scroll_offset_at_last_raster_.y() * zoom_ratio));
       }
 
       paint_manager_.SetTransform(zoom_ratio, pinch_center,
-          pinch_vector + paint_offset + scroll_delta,
-          true);
+                                  pinch_vector + paint_offset + scroll_delta,
+                                  true);
       needs_reraster_ = false;
       return;
     }
 
     if (pinch_phase == PINCH_UPDATE_ZOOM_OUT || pinch_phase == PINCH_END) {
       // We reraster on pinch zoom out in order to solve the invalid regions
       // that appear after zooming out.
       // On pinch end the scale is again 1.f and we request a reraster
       // in the new position.
       paint_manager_.ClearTransform();
@@ skipping 55 matching lines @@
 
     paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
   } else if (type == kJSLoadPreviewPageType &&
              dict.Get(pp::Var(kJSPreviewPageUrl)).is_string() &&
              dict.Get(pp::Var(kJSPreviewPageIndex)).is_int()) {
     std::string url = dict.Get(pp::Var(kJSPreviewPageUrl)).AsString();
     // For security reasons we crash if the URL that is trying to be loaded here
     // isn't a print preview one.
     CHECK(IsPrintPreview());
     CHECK(IsPrintPreviewUrl(url));
-    ProcessPreviewPageInfo(url,
-                           dict.Get(pp::Var(kJSPreviewPageIndex)).AsInt());
+    ProcessPreviewPageInfo(url, dict.Get(pp::Var(kJSPreviewPageIndex)).AsInt());
   } else if (type == kJSStopScrollingType) {
     stop_scrolling_ = true;
   } else if (type == kJSGetSelectedTextType) {
     std::string selected_text = engine_->GetSelectedText();
     // Always return unix newlines to JS.
     base::ReplaceChars(selected_text, "\r", std::string(), &selected_text);
     pp::VarDictionary reply;
     reply.Set(pp::Var(kType), pp::Var(kJSGetSelectedTextReplyType));
     reply.Set(pp::Var(kJSSelectedText), selected_text);
     PostMessage(reply);
   } else if (type == KJSGetNamedDestinationType &&
              dict.Get(pp::Var(KJSGetNamedDestination)).is_string()) {
     int page_number = engine_->GetNamedDestinationPage(
         dict.Get(pp::Var(KJSGetNamedDestination)).AsString());
     pp::VarDictionary reply;
     reply.Set(pp::Var(kType), pp::Var(kJSGetNamedDestinationReplyType));
     if (page_number >= 0)
       reply.Set(pp::Var(kJSNamedDestinationPageNumber), page_number);
     PostMessage(reply);
   } else {
     NOTREACHED();
   }
 }
 
-bool OutOfProcessInstance::HandleInputEvent(
-    const pp::InputEvent& event) {
+bool OutOfProcessInstance::HandleInputEvent(const pp::InputEvent& event) {
   // To simplify things, convert the event into device coordinates if it is
   // a mouse event.
   pp::InputEvent event_device_res(event);
   {
     pp::MouseInputEvent mouse_event(event);
     if (!mouse_event.is_null()) {
       pp::Point point = mouse_event.GetPosition();
       pp::Point movement = mouse_event.GetMovement();
       ScalePoint(device_scale_, &point);
       ScalePoint(device_scale_, &movement);
-      mouse_event = pp::MouseInputEvent(
-          this,
-          event.GetType(),
-          event.GetTimeStamp(),
-          event.GetModifiers(),
-          mouse_event.GetButton(),
-          point,
-          mouse_event.GetClickCount(),
-          movement);
+      mouse_event =
+          pp::MouseInputEvent(this, event.GetType(), event.GetTimeStamp(),
+                              event.GetModifiers(), mouse_event.GetButton(),
+                              point, mouse_event.GetClickCount(), movement);
       event_device_res = mouse_event;
     }
   }
 
   pp::InputEvent offset_event(event_device_res);
   switch (offset_event.GetType()) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
     case PP_INPUTEVENT_TYPE_MOUSEUP:
     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
     case PP_INPUTEVENT_TYPE_MOUSEENTER:
     case PP_INPUTEVENT_TYPE_MOUSELEAVE: {
       pp::MouseInputEvent mouse_event(event_device_res);
       pp::MouseInputEvent mouse_event_dip(event);
       pp::Point point = mouse_event.GetPosition();
       point.set_x(point.x() - available_area_.x());
       offset_event = pp::MouseInputEvent(
-          this,
-          event.GetType(),
-          event.GetTimeStamp(),
-          event.GetModifiers(),
-          mouse_event.GetButton(),
-          point,
-          mouse_event.GetClickCount(),
+          this, event.GetType(), event.GetTimeStamp(), event.GetModifiers(),
+          mouse_event.GetButton(), point, mouse_event.GetClickCount(),
           mouse_event.GetMovement());
       break;
     }
     default:
       break;
   }
   if (engine_->HandleEvent(offset_event))
     return true;
 
   // Middle click is used for scrolling and is handled by the container page.
@@ skipping 14 matching lines @@
   pp::Size view_device_size(view_rect.width() * device_scale,
                             view_rect.height() * device_scale);
 
   if (view_device_size != plugin_size_ || device_scale != device_scale_) {
     device_scale_ = device_scale;
     plugin_dip_size_ = view_rect.size();
     plugin_size_ = view_device_size;
 
     paint_manager_.SetSize(view_device_size, device_scale_);
 
-    pp::Size new_image_data_size = PaintManager::GetNewContextSize(
-        image_data_.size(),
-        plugin_size_);
+    pp::Size new_image_data_size =
+        PaintManager::GetNewContextSize(image_data_.size(), plugin_size_);
     if (new_image_data_size != image_data_.size()) {
-      image_data_ = pp::ImageData(this,
-                                  PP_IMAGEDATAFORMAT_BGRA_PREMUL,
-                                  new_image_data_size,
-                                  false);
+      image_data_ = pp::ImageData(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                                  new_image_data_size, false);
       first_paint_ = true;
     }
 
     if (image_data_.is_null()) {
       DCHECK(plugin_size_.IsEmpty());
       return;
     }
 
     OnGeometryChanged(zoom_, old_device_scale);
   }
@@ skipping 34 matching lines @@
   if (document_load_state_ == LOAD_STATE_COMPLETE)
     LoadAccessibility();
 }
 
 void OutOfProcessInstance::LoadAccessibility() {
   accessibility_state_ = ACCESSIBILITY_STATE_LOADED;
   PP_PrivateAccessibilityDocInfo doc_info;
   doc_info.page_count = engine_->GetNumberOfPages();
   doc_info.text_accessible = PP_FromBool(
       engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE));
-  doc_info.text_copyable = PP_FromBool(
-      engine_->HasPermission(PDFEngine::PERMISSION_COPY));
+  doc_info.text_copyable =
+      PP_FromBool(engine_->HasPermission(PDFEngine::PERMISSION_COPY));
 
   pp::PDF::SetAccessibilityDocInfo(GetPluginInstance(), &doc_info);
 
   // If the document contents isn't accessible, don't send anything more.
   if (!(engine_->HasPermission(PDFEngine::PERMISSION_COPY) ||
         engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE))) {
     return;
   }
 
   SendAccessibilityViewportInfo();
@@ skipping 42 matching lines @@
 
     // We need to provide enough information to draw a bounding box
     // around any arbitrary text range, but the bounding boxes of characters
     // we get from PDFium don't necessarily "line up". Walk through the
     // characters in each text run and let the width of each character be
     // the difference between the x coordinate of one character and the
     // x coordinate of the next. The rest of the bounds of each character
     // can be computed from the bounds of the text run.
     pp::FloatRect char_bounds = engine_->GetCharBounds(page_index, char_index);
     for (uint32_t i = 0; i < text_run_info.len - 1; i++) {
-      DCHECK_LT(char_index + i + 1,
-                static_cast<uint32_t>(char_count));
-      pp::FloatRect next_char_bounds = engine_->GetCharBounds(
-          page_index, char_index + i + 1);
+      DCHECK_LT(char_index + i + 1, static_cast<uint32_t>(char_count));
+      pp::FloatRect next_char_bounds =
+          engine_->GetCharBounds(page_index, char_index + i + 1);
       chars[char_index + i].char_width = next_char_bounds.x() - char_bounds.x();
       char_bounds = next_char_bounds;
     }
     chars[char_index + text_run_info.len - 1].char_width = char_bounds.width();
 
     char_index += text_run_info.len;
   }
 
   page_info.text_run_count = text_runs.size();
   pp::PDF::SetAccessibilityPageInfo(GetPluginInstance(), &page_info,
                                     text_runs.data(), chars.data());
 
   // Schedule loading the next page.
   pp::CompletionCallback callback = timer_factory_.NewCallback(
       &OutOfProcessInstance::SendNextAccessibilityPage);
   pp::Module::Get()->core()->CallOnMainThread(kAccessibilityPageDelayMs,
                                               callback, page_index + 1);
 }
 
 void OutOfProcessInstance::SendAccessibilityViewportInfo() {
   PP_PrivateAccessibilityViewportInfo viewport_info;
   viewport_info.scroll.x = 0;
   viewport_info.scroll.y = -top_toolbar_height_ * device_scale_;
   viewport_info.offset = available_area_.point();
   viewport_info.zoom = zoom_ * device_scale_;
   pp::PDF::SetAccessibilityViewportInfo(GetPluginInstance(), &viewport_info);
 }
 
-pp::Var OutOfProcessInstance::GetLinkAtPosition(
-    const pp::Point& point) {
+pp::Var OutOfProcessInstance::GetLinkAtPosition(const pp::Point& point) {
   pp::Point offset_point(point);
   ScalePoint(device_scale_, &offset_point);
   offset_point.set_x(offset_point.x() - available_area_.x());
   return engine_->GetLinkAtPosition(offset_point);
 }
 
 uint32_t OutOfProcessInstance::QuerySupportedPrintOutputFormats() {
   return engine_->QuerySupportedPrintOutputFormats();
 }
 
@@ skipping 46 matching lines @@
 void OutOfProcessInstance::SelectFindResult(bool forward) {
   engine_->SelectFindResult(forward);
 }
 
 void OutOfProcessInstance::StopFind() {
   engine_->StopFind();
   tickmarks_.clear();
   SetTickmarks(tickmarks_);
 }
 
-void OutOfProcessInstance::OnPaint(
-    const std::vector<pp::Rect>& paint_rects,
-    std::vector<PaintManager::ReadyRect>* ready,
-    std::vector<pp::Rect>* pending) {
+void OutOfProcessInstance::OnPaint(const std::vector<pp::Rect>& paint_rects,
+                                   std::vector<PaintManager::ReadyRect>* ready,
+                                   std::vector<pp::Rect>* pending) {
   if (image_data_.is_null()) {
     DCHECK(plugin_size_.IsEmpty());
     return;
   }
   if (first_paint_) {
     first_paint_ = false;
     pp::Rect rect = pp::Rect(pp::Point(), image_data_.size());
     FillRect(rect, background_color_);
     ready->push_back(PaintManager::ReadyRect(rect, image_data_, true));
   }
 
   if (!received_viewport_message_ || !needs_reraster_)
     return;
 
   engine_->PrePaint();
 
   for (const auto& paint_rect : paint_rects) {
     // Intersect with plugin area since there could be pending invalidates from
     // when the plugin area was larger.
-    pp::Rect rect =
-        paint_rect.Intersect(pp::Rect(pp::Point(), plugin_size_));
+    pp::Rect rect = paint_rect.Intersect(pp::Rect(pp::Point(), plugin_size_));
     if (rect.IsEmpty())
       continue;
 
     pp::Rect pdf_rect = available_area_.Intersect(rect);
     if (!pdf_rect.IsEmpty()) {
       pdf_rect.Offset(available_area_.x() * -1, 0);
 
       std::vector<pp::Rect> pdf_ready;
       std::vector<pp::Rect> pdf_pending;
       engine_->Paint(pdf_rect, &image_data_, &pdf_ready, &pdf_pending);
       for (auto& ready_rect : pdf_ready) {
         ready_rect.Offset(available_area_.point());
         ready->push_back(
             PaintManager::ReadyRect(ready_rect, image_data_, false));
       }
       for (auto& pending_rect : pdf_pending) {
         pending_rect.Offset(available_area_.point());
         pending->push_back(pending_rect);
       }
     }
 
     // Ensure the region above the first page (if any) is filled;
-    int32_t first_page_ypos = engine_->GetNumberOfPages() == 0 ?
-        0 : engine_->GetPageScreenRect(0).y();
+    int32_t first_page_ypos = engine_->GetNumberOfPages() == 0
+                                  ? 0
+                                  : engine_->GetPageScreenRect(0).y();
     if (rect.y() < first_page_ypos) {
       pp::Rect region = rect.Intersect(pp::Rect(
           pp::Point(), pp::Size(plugin_size_.width(), first_page_ypos)));
       ready->push_back(PaintManager::ReadyRect(region, image_data_, false));
       FillRect(region, background_color_);
     }
 
     for (const auto& background_part : background_parts_) {
       pp::Rect intersection = background_part.location.Intersect(rect);
       if (!intersection.IsEmpty()) {
         FillRect(intersection, background_part.color);
         ready->push_back(
             PaintManager::ReadyRect(intersection, image_data_, false));
       }
     }
   }
 
   engine_->PostPaint();
 }
 
 void OutOfProcessInstance::DidOpen(int32_t result) {
   if (result == PP_OK) {
     if (!engine_->HandleDocumentLoad(embed_loader_)) {
       document_load_state_ = LOAD_STATE_LOADING;
       DocumentLoadFailed();
     }
-  } else if (result != PP_ERROR_ABORTED) { // Can happen in tests.
+  } else if (result != PP_ERROR_ABORTED) {  // Can happen in tests.
     NOTREACHED();
     DocumentLoadFailed();
   }
 
   // If it's a progressive load, cancel the stream URL request so that requests
   // can be made on the original URL.
   // TODO(raymes): Make this clearer once the in-process plugin is deleted.
   if (engine_->IsProgressiveLoad()) {
     pp::VarDictionary message;
     message.Set(kType, kJSCancelStreamUrlType);
@@ skipping 17 matching lines @@
 
 void OutOfProcessInstance::CalculateBackgroundParts() {
   background_parts_.clear();
   int left_width = available_area_.x();
   int right_start = available_area_.right();
   int right_width = abs(plugin_size_.width() - available_area_.right());
   int bottom = std::min(available_area_.bottom(), plugin_size_.height());
 
   // Add the left, right, and bottom rectangles.  Note: we assume only
   // horizontal centering.
-  BackgroundPart part = {
-    pp::Rect(0, 0, left_width, bottom),
-    background_color_
-  };
+  BackgroundPart part = {pp::Rect(0, 0, left_width, bottom), background_color_};
   if (!part.location.IsEmpty())
     background_parts_.push_back(part);
   part.location = pp::Rect(right_start, 0, right_width, bottom);
   if (!part.location.IsEmpty())
     background_parts_.push_back(part);
-  part.location = pp::Rect(
-      0, bottom, plugin_size_.width(), plugin_size_.height() - bottom);
+  part.location =
+      pp::Rect(0, bottom, plugin_size_.width(), plugin_size_.height() - bottom);
   if (!part.location.IsEmpty())
     background_parts_.push_back(part);
 }
 
 int OutOfProcessInstance::GetDocumentPixelWidth() const {
   return static_cast<int>(ceil(document_size_.width() * zoom_ * device_scale_));
 }
 
 int OutOfProcessInstance::GetDocumentPixelHeight() const {
   return static_cast<int>(
       ceil(document_size_.height() * zoom_ * device_scale_));
 }
 
 void OutOfProcessInstance::FillRect(const pp::Rect& rect, uint32_t color) {
   DCHECK(!image_data_.is_null() || rect.IsEmpty());
   uint32_t* buffer_start = static_cast<uint32_t*>(image_data_.data());
   int stride = image_data_.stride();
   uint32_t* ptr = buffer_start + rect.y() * stride / 4 + rect.x();
   int height = rect.height();
   int width = rect.width();
   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x)
       *(ptr + x) = color;
-    ptr += stride /4;
+    ptr += stride / 4;
   }
 }
 
 void OutOfProcessInstance::DocumentSizeUpdated(const pp::Size& size) {
   document_size_ = size;
 
   pp::VarDictionary dimensions;
   dimensions.Set(kType, kJSDocumentDimensionsType);
   dimensions.Set(kJSDocumentWidth, pp::Var(document_size_.width()));
   dimensions.Set(kJSDocumentHeight, pp::Var(document_size_.height()));
@@ skipping 59 matching lines @@
   PostMessage(message);
 }
 
 void OutOfProcessInstance::UpdateCursor(PP_CursorType_Dev cursor) {
   if (cursor == cursor_)
     return;
   cursor_ = cursor;
 
   const PPB_CursorControl_Dev* cursor_interface =
       reinterpret_cast<const PPB_CursorControl_Dev*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_CURSOR_CONTROL_DEV_INTERFACE));
+          pp::Module::Get()->GetBrowserInterface(
+              PPB_CURSOR_CONTROL_DEV_INTERFACE));
   if (!cursor_interface) {
     NOTREACHED();
     return;
   }
 
-  cursor_interface->SetCursor(
-      pp_instance(), cursor_, pp::ImageData().pp_resource(), nullptr);
+  cursor_interface->SetCursor(pp_instance(), cursor_,
+                              pp::ImageData().pp_resource(), nullptr);
 }
 
 void OutOfProcessInstance::UpdateTickMarks(
     const std::vector<pp::Rect>& tickmarks) {
   float inverse_scale = 1.0f / device_scale_;
   std::vector<pp::Rect> scaled_tickmarks = tickmarks;
   for (auto& tickmark : scaled_tickmarks)
     ScaleRect(inverse_scale, &tickmark);
   tickmarks_ = scaled_tickmarks;
 }
 
 void OutOfProcessInstance::NotifyNumberOfFindResultsChanged(int total,
                                                             bool final_result) {
   // We don't want to spam the renderer with too many updates to the number of
   // find results. Don't send an update if we sent one too recently. If it's the
   // final update, we always send it though.
   if (final_result) {
     NumberOfFindResultsChanged(total, final_result);
     SetTickmarks(tickmarks_);
     return;
   }
 
   if (recently_sent_find_update_)
     return;
 
   NumberOfFindResultsChanged(total, final_result);
   SetTickmarks(tickmarks_);
   recently_sent_find_update_ = true;
-  pp::CompletionCallback callback =
-      timer_factory_.NewCallback(
-          &OutOfProcessInstance::ResetRecentlySentFindUpdate);
-  pp::Module::Get()->core()->CallOnMainThread(kFindResultCooldownMs,
-                                              callback, 0);
+  pp::CompletionCallback callback = timer_factory_.NewCallback(
+      &OutOfProcessInstance::ResetRecentlySentFindUpdate);
+  pp::Module::Get()->core()->CallOnMainThread(kFindResultCooldownMs, callback,
+                                              0);
 }
 
 void OutOfProcessInstance::NotifySelectedFindResultChanged(
     int current_find_index) {
   DCHECK_GE(current_find_index, 0);
   SelectedFindResultChanged(current_find_index);
 }
 
 void OutOfProcessInstance::GetDocumentPassword(
     pp::CompletionCallbackWithOutput<pp::Var> callback) {
@@ skipping 96 matching lines @@
 pp::URLLoader OutOfProcessInstance::CreateURLLoader() {
   if (full_) {
     if (!did_call_start_loading_) {
       did_call_start_loading_ = true;
       pp::PDF::DidStartLoading(this);
     }
 
     // Disable save and print until the document is fully loaded, since they
     // would generate an incomplete document.  Need to do this each time we
     // call DidStartLoading since that resets the content restrictions.
-    pp::PDF::SetContentRestriction(this, CONTENT_RESTRICTION_SAVE |
-                                   CONTENT_RESTRICTION_PRINT);
+    pp::PDF::SetContentRestriction(
+        this, CONTENT_RESTRICTION_SAVE | CONTENT_RESTRICTION_PRINT);
   }
 
   return CreateURLLoaderInternal();
 }
 
 void OutOfProcessInstance::ScheduleCallback(int id, int delay_in_ms) {
   pp::CompletionCallback callback =
       timer_factory_.NewCallback(&OutOfProcessInstance::OnClientTimerFired);
   pp::Module::Get()->core()->CallOnMainThread(delay_in_ms, callback, id);
 }
 
-void OutOfProcessInstance::SearchString(const base::char16* string,
-                            const base::char16* term,
-                            bool case_sensitive,
-                            std::vector<SearchStringResult>* results) {
+void OutOfProcessInstance::SearchString(
+    const base::char16* string,
+    const base::char16* term,
+    bool case_sensitive,
+    std::vector<SearchStringResult>* results) {
   PP_PrivateFindResult* pp_results;
   int count = 0;
-  pp::PDF::SearchString(
-      this,
-      reinterpret_cast<const unsigned short*>(string),
-      reinterpret_cast<const unsigned short*>(term),
-      case_sensitive,
-      &pp_results,
-      &count);
+  pp::PDF::SearchString(this, reinterpret_cast<const unsigned short*>(string),
+                        reinterpret_cast<const unsigned short*>(term),
+                        case_sensitive, &pp_results, &count);
 
   results->resize(count);
   for (int i = 0; i < count; ++i) {
     (*results)[i].start_index = pp_results[i].start_index;
     (*results)[i].length = pp_results[i].length;
   }
 
   pp::Memory_Dev memory;
   memory.MemFree(pp_results);
 }
 
-void OutOfProcessInstance::DocumentPaintOccurred() {
-}
+void OutOfProcessInstance::DocumentPaintOccurred() {}
 
 void OutOfProcessInstance::DocumentLoadComplete(int page_count) {
   // Clear focus state for OSK.
   FormTextFieldFocusChange(false);
 
   DCHECK_EQ(LOAD_STATE_LOADING, document_load_state_);
   document_load_state_ = LOAD_STATE_COMPLETE;
   UserMetricsRecordAction("PDF.LoadSuccess");
   uma_.HistogramEnumeration("PDF.DocumentFeature", LOADED_DOCUMENT,
                             FEATURES_COUNT);
@@ skipping 66 matching lines @@
   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
       preview_pages_info_.empty()) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_COMPLETE;
 
   int dest_page_index = preview_pages_info_.front().second;
   int src_page_index =
       ExtractPrintPreviewPageIndex(preview_pages_info_.front().first);
-  if (src_page_index > 0 &&  dest_page_index > -1 && preview_engine_.get())
+  if (src_page_index > 0 && dest_page_index > -1 && preview_engine_.get())
     engine_->AppendPage(preview_engine_.get(), dest_page_index);
 
   preview_pages_info_.pop();
   // |print_preview_page_count_| is not updated yet. Do not load any
   // other preview pages till we get this information.
   if (print_preview_page_count_ == 0)
     return;
 
   if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
@@ skipping 140 matching lines @@
 }
 
 void OutOfProcessInstance::LoadPreviewUrl(const std::string& url) {
   LoadUrlInternal(url, &embed_preview_loader_,
                   &OutOfProcessInstance::DidOpenPreview);
 }
 
 void OutOfProcessInstance::LoadUrlInternal(
     const std::string& url,
     pp::URLLoader* loader,
-    void (OutOfProcessInstance::* method)(int32_t)) {
+    void (OutOfProcessInstance::*method)(int32_t)) {
   pp::URLRequestInfo request(this);
   request.SetURL(url);
   request.SetMethod("GET");
   request.SetFollowRedirects(false);
 
   *loader = CreateURLLoaderInternal();
   pp::CompletionCallback callback = loader_factory_.NewCallback(method);
   int rv = loader->Open(request, callback);
   if (rv != PP_OK_COMPLETIONPENDING)
     callback.Run(rv);
@@ skipping 54 matching lines @@
 
 void OutOfProcessInstance::LoadAvailablePreviewPage() {
   if (preview_pages_info_.empty() ||
       document_load_state_ != LOAD_STATE_COMPLETE) {
     return;
   }
 
   std::string url = preview_pages_info_.front().first;
   int dst_page_index = preview_pages_info_.front().second;
   int src_page_index = ExtractPrintPreviewPageIndex(url);
-  if (src_page_index < 1 ||
-      dst_page_index >= print_preview_page_count_ ||
+  if (src_page_index < 1 || dst_page_index >= print_preview_page_count_ ||
       preview_document_load_state_ == LOAD_STATE_LOADING) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_LOADING;
   LoadPreviewUrl(url);
 }
 
-void OutOfProcessInstance::UserMetricsRecordAction(
-    const std::string& action) {
+void OutOfProcessInstance::UserMetricsRecordAction(const std::string& action) {
   // TODO(raymes): Move this function to PPB_UMA_Private.
   pp::PDF::UserMetricsRecordAction(this, pp::Var(action));
 }
 
 pp::FloatPoint OutOfProcessInstance::BoundScrollOffsetToDocument(
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf