Clang format pdf/

pdf/pdfium/pdfium_engine.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/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 173 matching lines @@
   } else if (pitch_family & FXFONT_FF_ROMAN) {
     description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SERIF);
   }
 
   static const struct {
     const char* pdf_name;
     const char* face;
     bool bold;
     bool italic;
   } kPdfFontSubstitutions[] = {
-    {"Courier", "Courier New", false, false},
-    {"Courier-Bold", "Courier New", true, false},
-    {"Courier-BoldOblique", "Courier New", true, true},
-    {"Courier-Oblique", "Courier New", false, true},
-    {"Helvetica", "Arial", false, false},
-    {"Helvetica-Bold", "Arial", true, false},
-    {"Helvetica-BoldOblique", "Arial", true, true},
-    {"Helvetica-Oblique", "Arial", false, true},
-    {"Times-Roman", "Times New Roman", false, false},
-    {"Times-Bold", "Times New Roman", true, false},
-    {"Times-BoldItalic", "Times New Roman", true, true},
-    {"Times-Italic", "Times New Roman", false, true},
+      {"Courier", "Courier New", false, false},
+      {"Courier-Bold", "Courier New", true, false},
+      {"Courier-BoldOblique", "Courier New", true, true},
+      {"Courier-Oblique", "Courier New", false, true},
+      {"Helvetica", "Arial", false, false},
+      {"Helvetica-Bold", "Arial", true, false},
+      {"Helvetica-BoldOblique", "Arial", true, true},
+      {"Helvetica-Oblique", "Arial", false, true},
+      {"Times-Roman", "Times New Roman", false, false},
+      {"Times-Bold", "Times New Roman", true, false},
+      {"Times-BoldItalic", "Times New Roman", true, true},
+      {"Times-Italic", "Times New Roman", false, true},
 
-    // MS P?(Mincho|Gothic) are the most notable fonts in Japanese PDF files
-    // without embedding the glyphs. Sometimes the font names are encoded
-    // in Japanese Windows's locale (CP932/Shift_JIS) without space.
-    // Most Linux systems don't have the exact font, but for outsourcing
-    // fontconfig to find substitutable font in the system, we pass ASCII
-    // font names to it.
-    {"MS-PGothic", "MS PGothic", false, false},
-    {"MS-Gothic", "MS Gothic", false, false},
-    {"MS-PMincho", "MS PMincho", false, false},
-    {"MS-Mincho", "MS Mincho", false, false},
-    // MS PGothic in Shift_JIS encoding.
-    {"\x82\x6C\x82\x72\x82\x6F\x83\x53\x83\x56\x83\x62\x83\x4E",
-     "MS PGothic", false, false},
-    // MS Gothic in Shift_JIS encoding.
-    {"\x82\x6C\x82\x72\x83\x53\x83\x56\x83\x62\x83\x4E",
-     "MS Gothic", false, false},
-    // MS PMincho in Shift_JIS encoding.
-    {"\x82\x6C\x82\x72\x82\x6F\x96\xBE\x92\xA9",
-     "MS PMincho", false, false},
-    // MS Mincho in Shift_JIS encoding.
-    {"\x82\x6C\x82\x72\x96\xBE\x92\xA9",
-     "MS Mincho", false, false},
+      // MS P?(Mincho|Gothic) are the most notable fonts in Japanese PDF files
+      // without embedding the glyphs. Sometimes the font names are encoded
+      // in Japanese Windows's locale (CP932/Shift_JIS) without space.
+      // Most Linux systems don't have the exact font, but for outsourcing
+      // fontconfig to find substitutable font in the system, we pass ASCII
+      // font names to it.
+      {"MS-PGothic", "MS PGothic", false, false},
+      {"MS-Gothic", "MS Gothic", false, false},
+      {"MS-PMincho", "MS PMincho", false, false},
+      {"MS-Mincho", "MS Mincho", false, false},
+      // MS PGothic in Shift_JIS encoding.
+      {"\x82\x6C\x82\x72\x82\x6F\x83\x53\x83\x56\x83\x62\x83\x4E", "MS PGothic",
+       false, false},
+      // MS Gothic in Shift_JIS encoding.
+      {"\x82\x6C\x82\x72\x83\x53\x83\x56\x83\x62\x83\x4E", "MS Gothic", false,
+       false},
+      // MS PMincho in Shift_JIS encoding.
+      {"\x82\x6C\x82\x72\x82\x6F\x96\xBE\x92\xA9", "MS PMincho", false, false},
+      // MS Mincho in Shift_JIS encoding.
+      {"\x82\x6C\x82\x72\x96\xBE\x92\xA9", "MS Mincho", false, false},
   };
 
   // Similar logic exists in PDFium's CFX_FolderFontInfo::FindFont().
   if (charset == FXFONT_ANSI_CHARSET && (pitch_family & FXFONT_FF_FIXEDPITCH))
     face = "Courier New";
 
   // Map from the standard PDF fonts to TrueType font names.
   size_t i;
   for (i = 0; i < arraysize(kPdfFontSubstitutions); ++i) {
     if (strcmp(face, kPdfFontSubstitutions[i].pdf_name) == 0) {
@@ skipping 58 matching lines @@
   if (!pp::PDF::GetFontTableForPrivateFontFile(res_id, table, buffer, &size))
     return 0;
   return size;
 }
 
 void DeleteFont(FPDF_SYSFONTINFO*, void* font_id) {
   long res_id = reinterpret_cast<long>(font_id);
   pp::Module::Get()->core()->ReleaseResource(res_id);
 }
 
-FPDF_SYSFONTINFO g_font_info = {
-  1,
-  0,
-  EnumFonts,
-  MapFont,
-  0,
-  GetFontData,
-  0,
-  0,
-  DeleteFont
-};
+FPDF_SYSFONTINFO g_font_info = {1,           0, EnumFonts, MapFont,   0,
+                                GetFontData, 0, 0,         DeleteFont};
 #else
 struct FPDF_SYSFONTINFO_WITHMETRICS : public FPDF_SYSFONTINFO {
   explicit FPDF_SYSFONTINFO_WITHMETRICS(FPDF_SYSFONTINFO* sysfontinfo) {
     version = sysfontinfo->version;
     default_sysfontinfo = sysfontinfo;
   }
 
   ~FPDF_SYSFONTINFO_WITHMETRICS() {
     FPDF_FreeDefaultSystemFontInfo(default_sysfontinfo);
   }
@@ skipping 98 matching lines @@
 
 void Unsupported_Handler(UNSUPPORT_INFO*, int type) {
   if (!g_engine_for_unsupported) {
     NOTREACHED();
     return;
   }
 
   g_engine_for_unsupported->UnsupportedFeature(type);
 }
 
-UNSUPPORT_INFO g_unsupported_info = {
-  1,
-  Unsupported_Handler
-};
+UNSUPPORT_INFO g_unsupported_info = {1, Unsupported_Handler};
 
 // Set the destination page size and content area in points based on source
 // page rotation and orientation.
 //
 // |rotated| True if source page is rotated 90 degree or 270 degree.
 // |is_src_page_landscape| is true if the source page orientation is landscape.
 // |page_size| has the actual destination page size in points.
 // |content_rect| has the actual destination page printable area values in
 // points.
 void SetPageSizeAndContentRect(bool rotated,
                                bool is_src_page_landscape,
                                pp::Size* page_size,
                                pp::Rect* content_rect) {
   bool is_dst_page_landscape = page_size->width() > page_size->height();
-  bool page_orientation_mismatched = is_src_page_landscape !=
-                                     is_dst_page_landscape;
+  bool page_orientation_mismatched =
+      is_src_page_landscape != is_dst_page_landscape;
   bool rotate_dst_page = rotated ^ page_orientation_mismatched;
   if (rotate_dst_page) {
     page_size->SetSize(page_size->height(), page_size->width());
     content_rect->SetRect(content_rect->y(), content_rect->x(),
                           content_rect->height(), content_rect->width());
   }
 }
 
 // This formats a string with special 0xfffe end-of-line hyphens the same way
 // as Adobe Reader. When a hyphen is encountered, the next non-CR/LF whitespace
@@ skipping 84 matching lines @@
   // Some bookmarks don't have a page to select.
   if (dest) {
     int page_index = FPDFDest_GetPageIndex(doc, dest);
     dict.Set(pp::Var("page"), pp::Var(page_index));
   } else {
     // Extract URI for bookmarks linking to an external page.
     FPDF_ACTION action = FPDFBookmark_GetAction(bookmark);
     buffer_size = FPDFAction_GetURIPath(doc, action, nullptr, 0);
     if (buffer_size > 0) {
       std::string uri;
-      PDFiumAPIStringBufferAdapter<std::string>
-          api_string_adapter(&uri, buffer_size, true);
+      PDFiumAPIStringBufferAdapter<std::string> api_string_adapter(
+          &uri, buffer_size, true);
       api_string_adapter.Close(FPDFAction_GetURIPath(
           doc, action, api_string_adapter.GetData(), buffer_size));
       dict.Set(pp::Var("uri"), pp::Var(uri));
     }
   }
 
   pp::VarArray children;
 
   // Don't trust PDFium to handle circular bookmarks.
   const unsigned int kMaxDepth = 128;
@@ skipping 305 matching lines @@
   int platform_flag = -1;
 
 #if defined(WIN32)
   platform_flag = 0;
 #elif defined(__linux__)
   platform_flag = 1;
 #else
   platform_flag = 2;
 #endif
 
-  std::string javascript = "alert(\"Platform:"
-      + base::DoubleToString(platform_flag)
-      + "\")";
+  std::string javascript =
+      "alert(\"Platform:" + base::DoubleToString(platform_flag) + "\")";
 
   return platform_flag;
 }
 
 FPDF_BOOL PDFiumEngine::Form_PopupMenu(FPDF_FORMFILLINFO* param,
                                        FPDF_PAGE page,
                                        FPDF_WIDGET widget,
                                        int menu_flag,
                                        float x,
                                        float y) {
@@ skipping 11 matching lines @@
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
   std::string data_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data));
   std::string content_type_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(content_type));
   std::string encode_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(encode));
   std::string header_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(header));
 
-  std::string javascript = "alert(\"Post:"
-      + url_str + "," + data_str + "," + content_type_str + ","
-      + encode_str + "," + header_str
-      + "\")";
+  std::string javascript = "alert(\"Post:" + url_str + "," + data_str + "," +
+                           content_type_str + "," + encode_str + "," +
+                           header_str + "\")";
   return true;
 }
 
 FPDF_BOOL PDFiumEngine::Form_PutRequestURL(FPDF_FORMFILLINFO* param,
                                            FPDF_WIDESTRING url,
                                            FPDF_WIDESTRING data,
                                            FPDF_WIDESTRING encode) {
   std::string url_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
   std::string data_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data));
   std::string encode_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(encode));
 
-  std::string javascript = "alert(\"Put:"
-      + url_str + "," + data_str + "," + encode_str
-      + "\")";
+  std::string javascript =
+      "alert(\"Put:" + url_str + "," + data_str + "," + encode_str + "\")";
 
   return true;
 }
 
 void PDFiumEngine::Form_UploadTo(FPDF_FORMFILLINFO* param,
                                  FPDF_FILEHANDLER* file_handle,
                                  int file_flag,
                                  FPDF_WIDESTRING to) {
   std::string to_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(to));
@@ skipping 25 matching lines @@
 }
 
 int PDFiumEngine::Form_GetLanguage(FPDF_FORMFILLINFO* param,
                                    void* language,
                                    int length) {
   return 0;
 }
 
 #endif  // defined(PDF_ENABLE_XFA)
 
-int PDFiumEngine::GetBlock(void* param, unsigned long position,
-                           unsigned char* buffer, unsigned long size) {
+int PDFiumEngine::GetBlock(void* param,
+                           unsigned long position,
+                           unsigned char* buffer,
+                           unsigned long size) {
   DocumentLoader* loader = static_cast<DocumentLoader*>(param);
   return loader->GetBlock(position, size, buffer);
 }
 
 FPDF_BOOL PDFiumEngine::IsDataAvail(FX_FILEAVAIL* param,
-                                    size_t offset, size_t size) {
+                                    size_t offset,
+                                    size_t size) {
   PDFiumEngine::FileAvail* file_avail =
       static_cast<PDFiumEngine::FileAvail*>(param);
   return file_avail->loader->IsDataAvailable(offset, size);
 }
 
 void PDFiumEngine::AddSegment(FX_DOWNLOADHINTS* param,
-                              size_t offset, size_t size) {
+                              size_t offset,
+                              size_t size) {
   PDFiumEngine::DownloadHints* download_hints =
       static_cast<PDFiumEngine::DownloadHints*>(param);
   return download_hints->loader->RequestData(offset, size);
 }
 
-bool PDFiumEngine::New(const char* url,
-                       const char* headers) {
+bool PDFiumEngine::New(const char* url, const char* headers) {
   url_ = url;
   if (headers)
     headers_ = headers;
   else
     headers_.clear();
   return true;
 }
 
 void PDFiumEngine::PageOffsetUpdated(const pp::Point& page_offset) {
   page_offset_ = page_offset;
@@ skipping 100 matching lines @@
 }
 
 void PDFiumEngine::PostPaint() {
   for (size_t i = 0; i < progressive_paints_.size(); ++i) {
     if (progressive_paints_[i].painted_)
       continue;
 
     // This rectangle must have been merged with another one, that's why we
     // weren't asked to paint it. Remove it or otherwise we'll never finish
     // painting.
-    FPDF_RenderPage_Close(
-        pages_[progressive_paints_[i].page_index]->GetPage());
+    FPDF_RenderPage_Close(pages_[progressive_paints_[i].page_index]->GetPage());
     FPDFBitmap_Destroy(progressive_paints_[i].bitmap);
     progressive_paints_.erase(progressive_paints_.begin() + i);
     --i;
   }
 }
 
 bool PDFiumEngine::HandleDocumentLoad(const pp::URLLoader& loader) {
   password_tries_remaining_ = kMaxPasswordTries;
   return doc_loader_.Init(loader, url_, headers_);
 }
 
 pp::Instance* PDFiumEngine::GetPluginInstance() {
   return client_->GetPluginInstance();
 }
 
 pp::URLLoader PDFiumEngine::CreateURLLoader() {
   return client_->CreateURLLoader();
 }
 
 void PDFiumEngine::AppendPage(PDFEngine* engine, int index) {
   // Unload and delete the blank page before appending.
   pages_[index]->Unload();
   pages_[index]->set_calculated_links(false);
   pp::Size curr_page_size = GetPageSize(index);
   FPDFPage_Delete(doc_, index);
-  FPDF_ImportPages(doc_,
-                   static_cast<PDFiumEngine*>(engine)->doc(),
-                   "1",
-                   index);
+  FPDF_ImportPages(doc_, static_cast<PDFiumEngine*>(engine)->doc(), "1", index);
   pp::Size new_page_size = GetPageSize(index);
   if (curr_page_size != new_page_size)
     LoadPageInfo(true);
   client_->Invalidate(GetPageScreenRect(index));
 }
 
 #if defined(PDF_ENABLE_XFA)
 void PDFiumEngine::SetScrollPosition(const pp::Point& position) {
   position_ = position;
 }
@@ skipping 201 matching lines @@
   if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return PP_PRINTOUTPUTFORMAT_RASTER;
   return 0;
 }
 
 void PDFiumEngine::PrintBegin() {
   FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WP);
 }
 
 pp::Resource PDFiumEngine::PrintPages(
-    const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
+    const PP_PrintPageNumberRange_Dev* page_ranges,
+    uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
   ScopedSubstFont scoped_subst_font(this);
   if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY) &&
       (print_settings.format & PP_PRINTOUTPUTFORMAT_PDF)) {
     return PrintPagesAsPDF(page_ranges, page_range_count, print_settings);
   } else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY)) {
     return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings);
   }
 
   return pp::Resource();
 }
 
 FPDF_DOCUMENT PDFiumEngine::CreateSinglePageRasterPdf(
     double source_page_width,
     double source_page_height,
     const PP_PrintSettings_Dev& print_settings,
     PDFiumPage* page_to_print) {
   FPDF_DOCUMENT temp_doc = FPDF_CreateNewDocument();
   if (!temp_doc)
     return temp_doc;
 
   const pp::Size& bitmap_size(page_to_print->rect().size());
 
   FPDF_PAGE temp_page =
       FPDFPage_New(temp_doc, 0, source_page_width, source_page_height);
 
-  pp::ImageData image = pp::ImageData(client_->GetPluginInstance(),
-                                      PP_IMAGEDATAFORMAT_BGRA_PREMUL,
-                                      bitmap_size,
-                                      false);
+  pp::ImageData image =
+      pp::ImageData(client_->GetPluginInstance(),
+                    PP_IMAGEDATAFORMAT_BGRA_PREMUL, bitmap_size, false);
 
-  FPDF_BITMAP bitmap = FPDFBitmap_CreateEx(bitmap_size.width(),
-                                           bitmap_size.height(),
-                                           FPDFBitmap_BGRx,
-                                           image.data(),
-                                           image.stride());
+  FPDF_BITMAP bitmap =
+      FPDFBitmap_CreateEx(bitmap_size.width(), bitmap_size.height(),
+                          FPDFBitmap_BGRx, image.data(), image.stride());
 
   // Clear the bitmap
-  FPDFBitmap_FillRect(
-      bitmap, 0, 0, bitmap_size.width(), bitmap_size.height(), 0xFFFFFFFF);
+  FPDFBitmap_FillRect(bitmap, 0, 0, bitmap_size.width(), bitmap_size.height(),
+                      0xFFFFFFFF);
 
   pp::Rect page_rect = page_to_print->rect();
-  FPDF_RenderPageBitmap(bitmap,
-                        page_to_print->GetPrintPage(),
-                        page_rect.x(),
-                        page_rect.y(),
-                        page_rect.width(),
-                        page_rect.height(),
+  FPDF_RenderPageBitmap(bitmap, page_to_print->GetPrintPage(), page_rect.x(),
+                        page_rect.y(), page_rect.width(), page_rect.height(),
                         print_settings.orientation,
                         FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
   unsigned char* bitmap_data =
       static_cast<unsigned char*>(FPDFBitmap_GetBuffer(bitmap));
-  double ratio_x = ConvertUnitDouble(bitmap_size.width(),
-                                     print_settings.dpi,
+  double ratio_x = ConvertUnitDouble(bitmap_size.width(), print_settings.dpi,
                                      kPointsPerInch);
-  double ratio_y = ConvertUnitDouble(bitmap_size.height(),
-                                     print_settings.dpi,
+  double ratio_y = ConvertUnitDouble(bitmap_size.height(), print_settings.dpi,
                                      kPointsPerInch);
 
   // Add the bitmap to an image object and add the image object to the output
   // page.
   FPDF_PAGEOBJECT temp_img = FPDFPageObj_NewImageObj(temp_doc);
 
   std::vector<uint8_t> compressed_bitmap_data;
   // Use quality = 40 as this does not significantly degrade the printed
   // document relative to a normal bitmap and provides better compression than
   // a higher quality setting.
@@ skipping 19 matching lines @@
   FPDFPage_GenerateContent(temp_page);
   FPDF_ClosePage(temp_page);
 
   page_to_print->ClosePrintPage();
   FPDFBitmap_Destroy(bitmap);
 
   return temp_doc;
 }
 
 pp::Buffer_Dev PDFiumEngine::PrintPagesAsRasterPDF(
-    const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
+    const PP_PrintPageNumberRange_Dev* page_ranges,
+    uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
   if (!page_range_count)
     return pp::Buffer_Dev();
 
   // If document is not downloaded yet, disable printing.
   if (doc_ && !doc_loader_.IsDocumentComplete())
     return pp::Buffer_Dev();
 
   FPDF_DOCUMENT output_doc = FPDF_CreateNewDocument();
   if (!output_doc)
     return pp::Buffer_Dev();
 
   SaveSelectedFormForPrint();
 
   std::vector<PDFiumPage> pages_to_print;
   // width and height of source PDF pages.
-  std::vector<std::pair<double, double> > source_page_sizes;
+  std::vector<std::pair<double, double>> source_page_sizes;
   // Collect pages to print and sizes of source pages.
   std::vector<uint32_t> page_numbers =
       GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count);
   for (uint32_t page_number : page_numbers) {
     FPDF_PAGE pdf_page = FPDF_LoadPage(doc_, page_number);
     double source_page_width = FPDF_GetPageWidth(pdf_page);
     double source_page_height = FPDF_GetPageHeight(pdf_page);
-    source_page_sizes.push_back(std::make_pair(source_page_width,
-                                               source_page_height));
+    source_page_sizes.push_back(
+        std::make_pair(source_page_width, source_page_height));
 
-    int width_in_pixels = ConvertUnit(source_page_width,
-                                      kPointsPerInch,
-                                      print_settings.dpi);
-    int height_in_pixels = ConvertUnit(source_page_height,
-                                       kPointsPerInch,
-                                       print_settings.dpi);
+    int width_in_pixels =
+        ConvertUnit(source_page_width, kPointsPerInch, print_settings.dpi);
+    int height_in_pixels =
+        ConvertUnit(source_page_height, kPointsPerInch, print_settings.dpi);
 
     pp::Rect rect(width_in_pixels, height_in_pixels);
     pages_to_print.push_back(PDFiumPage(this, page_number, rect, true));
     FPDF_ClosePage(pdf_page);
   }
 
 #if defined(OS_LINUX)
   g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
 
   size_t i = 0;
   for (; i < pages_to_print.size(); ++i) {
     double source_page_width = source_page_sizes[i].first;
     double source_page_height = source_page_sizes[i].second;
 
     // Use temp_doc to compress image by saving PDF to buffer.
-    FPDF_DOCUMENT temp_doc = CreateSinglePageRasterPdf(source_page_width,
-                                                       source_page_height,
-                                                       print_settings,
-                                                       &pages_to_print[i]);
+    FPDF_DOCUMENT temp_doc =
+        CreateSinglePageRasterPdf(source_page_width, source_page_height,
+                                  print_settings, &pages_to_print[i]);
 
     if (!temp_doc)
       break;
 
     pp::Buffer_Dev buffer = GetFlattenedPrintData(temp_doc);
     FPDF_CloseDocument(temp_doc);
 
     PDFiumMemBufferFileRead file_read(buffer.data(), buffer.size());
     temp_doc = FPDF_LoadCustomDocument(&file_read, nullptr);
 
@@ skipping 22 matching lines @@
     FPDF_PAGE page = FPDF_LoadPage(doc, i);
     DCHECK(page);
     int flatten_ret = FPDFPage_Flatten(page, FLAT_PRINT);
     FPDF_ClosePage(page);
     if (flatten_ret == FLATTEN_FAIL)
       return buffer;
   }
 
   PDFiumMemBufferFileWrite output_file_write;
   if (FPDF_SaveAsCopy(doc, &output_file_write, 0)) {
-    buffer = pp::Buffer_Dev(
-        client_->GetPluginInstance(), output_file_write.size());
+    buffer =
+        pp::Buffer_Dev(client_->GetPluginInstance(), output_file_write.size());
     if (!buffer.is_null()) {
       memcpy(buffer.data(), output_file_write.buffer().c_str(),
              output_file_write.size());
     }
   }
   return buffer;
 }
 
 pp::Buffer_Dev PDFiumEngine::PrintPagesAsPDF(
-    const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
+    const PP_PrintPageNumberRange_Dev* page_ranges,
+    uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
   if (!page_range_count)
     return pp::Buffer_Dev();
 
   DCHECK(doc_);
   FPDF_DOCUMENT output_doc = FPDF_CreateNewDocument();
   if (!output_doc)
     return pp::Buffer_Dev();
 
   SaveSelectedFormForPrint();
 
   std::string page_number_str;
   for (uint32_t index = 0; index < page_range_count; ++index) {
     if (!page_number_str.empty())
       page_number_str.append(",");
     page_number_str.append(
         base::UintToString(page_ranges[index].first_page_number + 1));
     if (page_ranges[index].first_page_number !=
-            page_ranges[index].last_page_number) {
+        page_ranges[index].last_page_number) {
       page_number_str.append("-");
       page_number_str.append(
           base::UintToString(page_ranges[index].last_page_number + 1));
     }
   }
 
   std::vector<uint32_t> page_numbers =
       GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count);
   for (uint32_t page_number : page_numbers) {
     pages_[page_number]->GetPage();
     if (!IsPageVisible(page_number))
       pages_[page_number]->Unload();
   }
 
   FPDF_CopyViewerPreferences(output_doc, doc_);
   if (!FPDF_ImportPages(output_doc, doc_, page_number_str.c_str(), 0)) {
     FPDF_CloseDocument(output_doc);
     return pp::Buffer_Dev();
   }
 
   FitContentsToPrintableAreaIfRequired(output_doc, print_settings);
 
   // Now flatten all the output pages.
   pp::Buffer_Dev buffer = GetFlattenedPrintData(output_doc);
   FPDF_CloseDocument(output_doc);
   return buffer;
 }
 
 void PDFiumEngine::FitContentsToPrintableAreaIfRequired(
-    const FPDF_DOCUMENT& doc, const PP_PrintSettings_Dev& print_settings) {
+    const FPDF_DOCUMENT& doc,
+    const PP_PrintSettings_Dev& print_settings) {
   // Check to see if we need to fit pdf contents to printer paper size.
   if (print_settings.print_scaling_option !=
-          PP_PRINTSCALINGOPTION_SOURCE_SIZE) {
+      PP_PRINTSCALINGOPTION_SOURCE_SIZE) {
     int num_pages = FPDF_GetPageCount(doc);
     // In-place transformation is more efficient than creating a new
     // transformed document from the source document. Therefore, transform
     // every page to fit the contents in the selected printer paper.
     for (int i = 0; i < num_pages; ++i) {
       FPDF_PAGE page = FPDF_LoadPage(doc, i);
       TransformPDFPageForPrinting(page, print_settings);
       FPDF_ClosePage(page);
     }
   }
@@ skipping 37 matching lines @@
     return PDFiumPage::NONSELECTABLE_AREA;
 
   // If the page hasn't finished rendering, calling into the page sometimes
   // leads to hangs.
   for (const auto& paint : progressive_paints_) {
     if (paint.page_index == page)
       return PDFiumPage::NONSELECTABLE_AREA;
   }
 
   *page_index = page;
-  return pages_[page]->GetCharIndex(
-      point_in_page, current_rotation_, char_index, form_type, target);
+  return pages_[page]->GetCharIndex(point_in_page, current_rotation_,
+                                    char_index, form_type, target);
 }
 
 bool PDFiumEngine::OnMouseDown(const pp::MouseInputEvent& event) {
   if (event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_RIGHT) {
     if (selection_.empty())
       return false;
     std::vector<pp::Rect> selection_rect_vector;
     GetAllScreenRectsUnion(&selection_, GetVisibleRect().point(),
                            &selection_rect_vector);
     pp::Point point = event.GetPosition();
@@ skipping 56 matching lines @@
     }
   }
 
   client_->FormTextFieldFocusChange(false);
 
   if (area != PDFiumPage::TEXT_AREA)
     return true;  // Return true so WebKit doesn't do its own highlighting.
 
   if (event.GetClickCount() == 1) {
     OnSingleClick(page_index, char_index);
-  } else if (event.GetClickCount() == 2 ||
-             event.GetClickCount() == 3) {
+  } else if (event.GetClickCount() == 2 || event.GetClickCount() == 3) {
     OnMultipleClick(event.GetClickCount(), page_index, char_index);
   }
 
   return true;
 }
 
 void PDFiumEngine::OnSingleClick(int page_index, int char_index) {
   SetSelecting(true);
   selection_.push_back(PDFiumRange(pages_[page_index].get(), char_index, 0));
 }
@@ skipping 43 matching lines @@
   if (mouse_down_state_.Matches(area, target)) {
     if (area == PDFiumPage::WEBLINK_AREA) {
       uint32_t modifiers = event.GetModifiers();
       bool middle_button =
           !!(modifiers & PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN);
       bool alt_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_ALTKEY);
       bool ctrl_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_CONTROLKEY);
       bool meta_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_METAKEY);
       bool shift_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_SHIFTKEY);
 
-      WindowOpenDisposition disposition =
-          ui::DispositionFromClick(middle_button, alt_key, ctrl_key, meta_key,
-                                   shift_key);
+      WindowOpenDisposition disposition = ui::DispositionFromClick(
+          middle_button, alt_key, ctrl_key, meta_key, shift_key);
 
       client_->NavigateTo(target.url, disposition);
       client_->FormTextFieldFocusChange(false);
       return true;
     }
   }
 
   // Prevent middle mouse button from selecting texts.
   if (event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_MIDDLE)
     return false;
 
   if (page_index != -1) {
     double page_x, page_y;
     pp::Point point = event.GetPosition();
     DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y);
-    FORM_OnLButtonUp(
-        form_, pages_[page_index]->GetPage(), 0, page_x, page_y);
+    FORM_OnLButtonUp(form_, pages_[page_index]->GetPage(), 0, page_x, page_y);
   }
 
   if (!selecting_)
     return false;
 
   SetSelecting(false);
   return true;
 }
 
 bool PDFiumEngine::OnMouseMove(const pp::MouseInputEvent& event) {
@@ skipping 122 matching lines @@
         PDFiumRange(pages_[page_index].get(), count, count - char_index));
   }
 
   return true;
 }
 
 bool PDFiumEngine::OnKeyDown(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
-  bool rv = !!FORM_OnKeyDown(
-      form_, pages_[last_page_mouse_down_]->GetPage(),
-      event.GetKeyCode(), event.GetModifiers());
+  bool rv = !!FORM_OnKeyDown(form_, pages_[last_page_mouse_down_]->GetPage(),
+                             event.GetKeyCode(), event.GetModifiers());
 
   if (event.GetKeyCode() == ui::VKEY_BACK ||
       event.GetKeyCode() == ui::VKEY_ESCAPE) {
     // Chrome doesn't send char events for backspace or escape keys, see
     // PlatformKeyboardEventBuilder::isCharacterKey() and
     // http://chrome-corpsvn.mtv.corp.google.com/viewvc?view=rev&root=chrome&revision=31805
     // for more information.  So just fake one since PDFium uses it.
     std::string str;
     str.push_back(event.GetKeyCode());
     pp::KeyboardInputEvent synthesized(pp::KeyboardInputEvent(
-        client_->GetPluginInstance(),
-        PP_INPUTEVENT_TYPE_CHAR,
-        event.GetTimeStamp(),
-        event.GetModifiers(),
-        event.GetKeyCode(),
-        str));
+        client_->GetPluginInstance(), PP_INPUTEVENT_TYPE_CHAR,
+        event.GetTimeStamp(), event.GetModifiers(), event.GetKeyCode(), str));
     OnChar(synthesized);
   }
 
   return rv;
 }
 
 bool PDFiumEngine::OnKeyUp(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
-  return !!FORM_OnKeyUp(
-      form_, pages_[last_page_mouse_down_]->GetPage(),
-      event.GetKeyCode(), event.GetModifiers());
+  return !!FORM_OnKeyUp(form_, pages_[last_page_mouse_down_]->GetPage(),
+                        event.GetKeyCode(), event.GetModifiers());
 }
 
 bool PDFiumEngine::OnChar(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
   base::string16 str = base::UTF8ToUTF16(event.GetCharacterText().AsString());
-  return !!FORM_OnChar(
-      form_, pages_[last_page_mouse_down_]->GetPage(),
-      str[0],
-      event.GetModifiers());
+  return !!FORM_OnChar(form_, pages_[last_page_mouse_down_]->GetPage(), str[0],
+                       event.GetModifiers());
 }
 
 void PDFiumEngine::StartFind(const std::string& text, bool case_sensitive) {
   // If the caller asks StartFind() to search for no text, then this is an
   // error on the part of the caller. The PPAPI Find_Private interface
   // guarantees it is not empty, so this should never happen.
   DCHECK(!text.empty());
 
   // If StartFind() gets called before we have any page information (i.e.
   // before the first call to LoadDocument has happened). Handle this case.
@@ skipping 21 matching lines @@
     }
   }
 
   int current_page = next_page_to_search_;
 
   if (pages_[current_page]->available()) {
     base::string16 str = base::UTF8ToUTF16(text);
     // Don't use PDFium to search for now, since it doesn't support unicode
     // text. Leave the code for now to avoid bit-rot, in case it's fixed later.
     if (0) {
-      SearchUsingPDFium(
-          str, case_sensitive, first_search, character_to_start_searching_from,
-          current_page);
+      SearchUsingPDFium(str, case_sensitive, first_search,
+                        character_to_start_searching_from, current_page);
     } else {
-      SearchUsingICU(
-          str, case_sensitive, first_search, character_to_start_searching_from,
-          current_page);
+      SearchUsingICU(str, case_sensitive, first_search,
+                     character_to_start_searching_from, current_page);
     }
 
     if (!IsPageVisible(current_page))
       pages_[current_page]->Unload();
   }
 
   if (next_page_to_search_ != last_page_to_search_ ||
       (first_search && last_character_index_to_search_ != -1)) {
     ++next_page_to_search_;
   }
@@ skipping 23 matching lines @@
         // This might happen if the PDF has some dynamically generated text?
         resume_index = 0;
       }
       current_find_index_.SetIndex(resume_index);
       client_->NotifySelectedFindResultChanged(resume_index);
     }
     resume_find_index_.Invalidate();
   } else {
     pp::CompletionCallback callback =
         find_factory_.NewCallback(&PDFiumEngine::ContinueFind);
-    pp::Module::Get()->core()->CallOnMainThread(
-        0, callback, case_sensitive ? 1 : 0);
+    pp::Module::Get()->core()->CallOnMainThread(0, callback,
+                                                case_sensitive ? 1 : 0);
   }
 }
 
 void PDFiumEngine::SearchUsingPDFium(const base::string16& term,
                                      bool case_sensitive,
                                      bool first_search,
                                      int character_to_start_searching_from,
                                      int current_page) {
   // Find all the matches in the current page.
   unsigned long flags = case_sensitive ? FPDF_MATCHCASE : 0;
-  FPDF_SCHHANDLE find = FPDFText_FindStart(
-      pages_[current_page]->GetTextPage(),
-      reinterpret_cast<const unsigned short*>(term.c_str()),
-      flags, character_to_start_searching_from);
+  FPDF_SCHHANDLE find =
+      FPDFText_FindStart(pages_[current_page]->GetTextPage(),
+                         reinterpret_cast<const unsigned short*>(term.c_str()),
+                         flags, character_to_start_searching_from);
 
   // Note: since we search one page at a time, we don't find matches across
   // page boundaries.  We could do this manually ourself, but it seems low
   // priority since Reader itself doesn't do it.
   while (FPDFText_FindNext(find)) {
     PDFiumRange result(pages_[current_page].get(),
                        FPDFText_GetSchResultIndex(find),
                        FPDFText_GetSchCount(find));
 
-    if (!first_search &&
-        last_character_index_to_search_ != -1 &&
+    if (!first_search && last_character_index_to_search_ != -1 &&
         result.page_index() == last_page_to_search_ &&
         result.char_index() >= last_character_index_to_search_) {
       break;
     }
 
     AddFindResult(result);
   }
 
   FPDFText_FindClose(find);
 }
 
 void PDFiumEngine::SearchUsingICU(const base::string16& term,
                                   bool case_sensitive,
                                   bool first_search,
                                   int character_to_start_searching_from,
                                   int current_page) {
   DCHECK(!term.empty());
 
   const int original_text_length = pages_[current_page]->GetCharCount();
   int text_length = original_text_length;
   if (character_to_start_searching_from) {
     text_length -= character_to_start_searching_from;
-  } else if (!first_search &&
-             last_character_index_to_search_ != -1 &&
+  } else if (!first_search && last_character_index_to_search_ != -1 &&
              current_page == last_page_to_search_) {
     text_length = last_character_index_to_search_;
   }
   if (text_length <= 0)
     return;
 
   base::string16 page_text;
-  PDFiumAPIStringBufferAdapter<base::string16> api_string_adapter(&page_text,
-                                                                  text_length,
-                                                                  false);
+  PDFiumAPIStringBufferAdapter<base::string16> api_string_adapter(
+      &page_text, text_length, false);
   unsigned short* data =
       reinterpret_cast<unsigned short*>(api_string_adapter.GetData());
-  int written = FPDFText_GetText(pages_[current_page]->GetTextPage(),
-                                 character_to_start_searching_from,
-                                 text_length,
-                                 data);
+  int written =
+      FPDFText_GetText(pages_[current_page]->GetTextPage(),
+                       character_to_start_searching_from, text_length, data);
   api_string_adapter.Close(written);
 
   std::vector<PDFEngine::Client::SearchStringResult> results;
-  client_->SearchString(
-      page_text.c_str(), term.c_str(), case_sensitive, &results);
+  client_->SearchString(page_text.c_str(), term.c_str(), case_sensitive,
+                        &results);
   for (const auto& result : results) {
     // Need to map the indexes from the page text, which may have generated
     // characters like space etc, to character indices from the page.
     int temp_start = result.start_index + character_to_start_searching_from;
     int start = FPDFText_GetCharIndexFromTextIndex(
         pages_[current_page]->GetTextPage(), temp_start);
     int end = FPDFText_GetCharIndexFromTextIndex(
-        pages_[current_page]->GetTextPage(),
-        temp_start + result.length);
+        pages_[current_page]->GetTextPage(), temp_start + result.length);
 
     // If |term| occurs at the end of a page, then |end| will be -1 due to the
     // index being out of bounds. Compensate for this case so the range
     // character count calculation below works out.
     if (temp_start + result.length == original_text_length) {
       DCHECK_EQ(-1, end);
       end = original_text_length;
     }
     DCHECK_LT(start, end);
     DCHECK_EQ(term.size(), static_cast<size_t>(end - start));
@@ skipping 38 matching lines @@
   }
 
   SelectionChangeInvalidator selection_invalidator(this);
 
   // Move back/forward through the search locations we previously found.
   size_t new_index;
   const size_t last_index = find_results_.size() - 1;
   if (current_find_index_.valid()) {
     size_t current_index = current_find_index_.GetIndex();
     if (forward) {
-      new_index = (current_index >= last_index) ?  0 : current_index + 1;
+      new_index = (current_index >= last_index) ? 0 : current_index + 1;
     } else {
-      new_index = (current_find_index_.GetIndex() == 0) ?
-          last_index : current_index - 1;
+      new_index = (current_find_index_.GetIndex() == 0) ? last_index
+                                                        : current_index - 1;
     }
   } else {
     new_index = forward ? 0 : last_index;
   }
   current_find_index_.SetIndex(new_index);
 
   // Update the selection before telling the client to scroll, since it could
   // paint then.
   selection_.clear();
   selection_.push_back(find_results_[current_find_index_.GetIndex()]);
 
   // If the result is not in view, scroll to it.
   pp::Rect bounding_rect;
   pp::Rect visible_rect = GetVisibleRect();
   // Use zoom of 1.0 since visible_rect is without zoom.
   std::vector<pp::Rect> rects =
       find_results_[current_find_index_.GetIndex()].GetScreenRects(
           pp::Point(), 1.0, current_rotation_);
   for (const auto& rect : rects)
     bounding_rect = bounding_rect.Union(rect);
   if (!visible_rect.Contains(bounding_rect)) {
     pp::Point center = bounding_rect.CenterPoint();
     // Make the page centered.
     int new_y = static_cast<int>(center.y() * current_zoom_) -
-        static_cast<int>(visible_rect.height() * current_zoom_ / 2);
+                static_cast<int>(visible_rect.height() * current_zoom_ / 2);
     if (new_y < 0)
       new_y = 0;
     client_->ScrollToY(new_y);
 
     // Only move horizontally if it's not visible.
     if (center.x() < visible_rect.x() || center.x() > visible_rect.right()) {
-      int new_x = static_cast<int>(center.x()  * current_zoom_) -
-          static_cast<int>(visible_rect.width() * current_zoom_ / 2);
+      int new_x = static_cast<int>(center.x() * current_zoom_) -
+                  static_cast<int>(visible_rect.width() * current_zoom_ / 2);
       if (new_x < 0)
         new_x = 0;
       client_->ScrollToX(new_x);
     }
   }
 
   client_->NotifySelectedFindResultChanged(current_find_index_.GetIndex());
   client_->NotifyNumberOfFindResultsChanged(find_results_.size(), true);
   return true;
 }
@@ skipping 58 matching lines @@
   client_->Invalidate(pp::Rect(plugin_size_));
 }
 
 std::string PDFiumEngine::GetSelectedText() {
   if (!HasPermission(PDFEngine::PERMISSION_COPY))
     return std::string();
 
   base::string16 result;
   base::string16 new_line_char = base::UTF8ToUTF16("\n");
   for (size_t i = 0; i < selection_.size(); ++i) {
-    if (i > 0 &&
-        selection_[i - 1].page_index() > selection_[i].page_index()) {
+    if (i > 0 && selection_[i - 1].page_index() > selection_[i].page_index()) {
       result = selection_[i].GetText() + new_line_char + result;
     } else {
       if (i > 0)
         result.append(new_line_char);
       result.append(selection_[i].GetText());
     }
   }
 
   FormatStringWithHyphens(&result);
   FormatStringForOS(&result);
@@ skipping 89 matching lines @@
   // to defer the page deletion otherwise we could potentially delete the page
   // that originated the calling JS request and destroy the objects that are
   // currently being used.
   base::AutoReset<bool> defer_page_unload_guard(&defer_page_unload_, true);
   CalculateVisiblePages();
   return most_visible_page_;
 }
 
 pp::Rect PDFiumEngine::GetPageRect(int index) {
   pp::Rect rc(pages_[index]->rect());
-  rc.Inset(-kPageShadowLeft, -kPageShadowTop,
-           -kPageShadowRight, -kPageShadowBottom);
+  rc.Inset(-kPageShadowLeft, -kPageShadowTop, -kPageShadowRight,
+           -kPageShadowBottom);
   return rc;
 }
 
 pp::Rect PDFiumEngine::GetPageBoundsRect(int index) {
   return pages_[index]->rect();
 }
 
 pp::Rect PDFiumEngine::GetPageContentsRect(int index) {
   return GetScreenRect(pages_[index]->rect());
 }
@@ skipping 100 matching lines @@
 
     pp::Rect rect(pp::Point(0, document_size_.height()), page_size);
     page_rects.push_back(rect);
 
     document_size_.Enlarge(0, page_size.height());
   }
 
   // Create blank pages.
   for (int i = 1; i < num_pages; ++i) {
     pp::Rect page_rect(page_rects[i]);
-    page_rect.Inset(kPageShadowLeft, kPageShadowTop,
-                    kPageShadowRight, kPageShadowBottom);
-    double width_in_points = ConvertUnitDouble(page_rect.width(),
-                                               kPixelsPerInch,
-                                               kPointsPerInch);
-    double height_in_points = ConvertUnitDouble(page_rect.height(),
-                                                kPixelsPerInch,
-                                                kPointsPerInch);
+    page_rect.Inset(kPageShadowLeft, kPageShadowTop, kPageShadowRight,
+                    kPageShadowBottom);
+    double width_in_points =
+        ConvertUnitDouble(page_rect.width(), kPixelsPerInch, kPointsPerInch);
+    double height_in_points =
+        ConvertUnitDouble(page_rect.height(), kPixelsPerInch, kPointsPerInch);
     FPDFPage_New(doc_, i, width_in_points, height_in_points);
     pages_.push_back(base::MakeUnique<PDFiumPage>(this, i, page_rect, true));
   }
 
   CalculateVisiblePages();
   if (document_size_ != old_document_size)
     client_->DocumentSizeUpdated(document_size_);
 }
 
 void PDFiumEngine::LoadDocument() {
@@ skipping 166 matching lines @@
     if (size.width() > document_size_.width())
       document_size_.set_width(size.width());
 
     document_size_.Enlarge(0, size.height());
   }
 
   for (int i = 0; i < page_count; ++i) {
     // Center pages relative to the entire document.
     page_rects[i].set_x((document_size_.width() - page_rects[i].width()) / 2);
     pp::Rect page_rect(page_rects[i]);
-    page_rect.Inset(kPageShadowLeft, kPageShadowTop,
-                    kPageShadowRight, kPageShadowBottom);
+    page_rect.Inset(kPageShadowLeft, kPageShadowTop, kPageShadowRight,
+                    kPageShadowBottom);
     if (reload) {
       pages_[i]->set_rect(page_rect);
     } else {
       // The page is marked as not being available even if |doc_complete| is
       // true because FPDFAvail_IsPageAvail() still has to be called for this
       // page, which will be done in FinishLoadingDocument().
       pages_.push_back(base::MakeUnique<PDFiumPage>(this, i, page_rect, false));
     }
   }
 
@@ skipping 84 matching lines @@
     pages_[index]->set_available(true);
   if (default_page_size_.IsEmpty())
     default_page_size_ = GetPageSize(index);
   return true;
 }
 
 pp::Size PDFiumEngine::GetPageSize(int index) {
   pp::Size size;
   double width_in_points = 0;
   double height_in_points = 0;
-  int rv = FPDF_GetPageSizeByIndex(
-      doc_, index, &width_in_points, &height_in_points);
+  int rv =
+      FPDF_GetPageSizeByIndex(doc_, index, &width_in_points, &height_in_points);
 
   if (rv) {
     int width_in_pixels = static_cast<int>(
         ConvertUnitDouble(width_in_points, kPointsPerInch, kPixelsPerInch));
     int height_in_pixels = static_cast<int>(
         ConvertUnitDouble(height_in_points, kPointsPerInch, kPixelsPerInch));
     if (current_rotation_ % 2 == 1)
       std::swap(width_in_pixels, height_in_pixels);
     size = pp::Size(width_in_pixels, height_in_pixels);
   }
@@ skipping 32 matching lines @@
   last_progressive_start_time_ = base::Time::Now();
   if (bitmap) {
     rv = FPDF_RenderPage_Continue(page, static_cast<IFSDK_PAUSE*>(this));
   } else {
     pp::Rect dirty = progressive_paints_[progressive_index].rect;
     bitmap = CreateBitmap(dirty, image_data);
     int start_x, start_y, size_x, size_y;
     GetPDFiumRect(page_index, dirty, &start_x, &start_y, &size_x, &size_y);
     FPDFBitmap_FillRect(bitmap, start_x, start_y, size_x, size_y, 0xFFFFFFFF);
     rv = FPDF_RenderPageBitmap_Start(
-        bitmap, page, start_x, start_y, size_x, size_y,
-        current_rotation_,
+        bitmap, page, start_x, start_y, size_x, size_y, current_rotation_,
         GetRenderingFlags(), static_cast<IFSDK_PAUSE*>(this));
     progressive_paints_[progressive_index].bitmap = bitmap;
   }
   return rv != FPDF_RENDER_TOBECOUNTINUED;
 }
 
 void PDFiumEngine::FinishPaint(int progressive_index,
                                pp::ImageData* image_data) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
   DCHECK(image_data);
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
   FPDF_BITMAP bitmap = progressive_paints_[progressive_index].bitmap;
   int start_x, start_y, size_x, size_y;
-  GetPDFiumRect(
-      page_index, dirty_in_screen, &start_x, &start_y, &size_x, &size_y);
+  GetPDFiumRect(page_index, dirty_in_screen, &start_x, &start_y, &size_x,
+                &size_y);
 
   // Draw the forms.
-  FPDF_FFLDraw(
-      form_, bitmap, pages_[page_index]->GetPage(), start_x, start_y, size_x,
-      size_y, current_rotation_, GetRenderingFlags());
+  FPDF_FFLDraw(form_, bitmap, pages_[page_index]->GetPage(), start_x, start_y,
+               size_x, size_y, current_rotation_, GetRenderingFlags());
 
   FillPageSides(progressive_index);
 
   // Paint the page shadows.
   PaintPageShadow(progressive_index, image_data);
 
   DrawSelections(progressive_index, image_data);
 
   FPDF_RenderPage_Close(pages_[page_index]->GetPage());
   FPDFBitmap_Destroy(bitmap);
@@ skipping 13 matching lines @@
 void PDFiumEngine::FillPageSides(int progressive_index) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
   FPDF_BITMAP bitmap = progressive_paints_[progressive_index].bitmap;
 
   pp::Rect page_rect = pages_[page_index]->rect();
   if (page_rect.x() > 0) {
-    pp::Rect left(0,
-                  page_rect.y() - kPageShadowTop,
+    pp::Rect left(0, page_rect.y() - kPageShadowTop,
                   page_rect.x() - kPageShadowLeft,
-                  page_rect.height() + kPageShadowTop +
-                      kPageShadowBottom + kPageSeparatorThickness);
+                  page_rect.height() + kPageShadowTop + kPageShadowBottom +
+                      kPageSeparatorThickness);
     left = GetScreenRect(left).Intersect(dirty_in_screen);
 
     FPDFBitmap_FillRect(bitmap, left.x() - dirty_in_screen.x(),
                         left.y() - dirty_in_screen.y(), left.width(),
                         left.height(), client_->GetBackgroundColor());
   }
 
   if (page_rect.right() < document_size_.width()) {
-    pp::Rect right(page_rect.right() + kPageShadowRight,
-                   page_rect.y() - kPageShadowTop,
-                   document_size_.width() - page_rect.right() -
-                      kPageShadowRight,
-                   page_rect.height() + kPageShadowTop +
-                       kPageShadowBottom + kPageSeparatorThickness);
+    pp::Rect right(
+        page_rect.right() + kPageShadowRight, page_rect.y() - kPageShadowTop,
+        document_size_.width() - page_rect.right() - kPageShadowRight,
+        page_rect.height() + kPageShadowTop + kPageShadowBottom +
+            kPageSeparatorThickness);
     right = GetScreenRect(right).Intersect(dirty_in_screen);
 
     FPDFBitmap_FillRect(bitmap, right.x() - dirty_in_screen.x(),
                         right.y() - dirty_in_screen.y(), right.width(),
                         right.height(), client_->GetBackgroundColor());
   }
 
   // Paint separator.
   pp::Rect bottom(page_rect.x() - kPageShadowLeft,
                   page_rect.bottom() + kPageShadowBottom,
                   page_rect.width() + kPageShadowLeft + kPageShadowRight,
                   kPageSeparatorThickness);
   bottom = GetScreenRect(bottom).Intersect(dirty_in_screen);
 
   FPDFBitmap_FillRect(bitmap, bottom.x() - dirty_in_screen.x(),
                       bottom.y() - dirty_in_screen.y(), bottom.width(),
                       bottom.height(), client_->GetBackgroundColor());
 }
 
 void PDFiumEngine::PaintPageShadow(int progressive_index,
                                    pp::ImageData* image_data) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
   DCHECK(image_data);
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
   pp::Rect page_rect = pages_[page_index]->rect();
   pp::Rect shadow_rect(page_rect);
-  shadow_rect.Inset(-kPageShadowLeft, -kPageShadowTop,
-                    -kPageShadowRight, -kPageShadowBottom);
+  shadow_rect.Inset(-kPageShadowLeft, -kPageShadowTop, -kPageShadowRight,
+                    -kPageShadowBottom);
 
   // Due to the rounding errors of the GetScreenRect it is possible to get
   // different size shadows on the left and right sides even they are defined
   // the same. To fix this issue let's calculate shadow rect and then shrink
   // it by the size of the shadows.
   shadow_rect = GetScreenRect(shadow_rect);
   page_rect = shadow_rect;
 
   page_rect.Inset(static_cast<int>(ceil(kPageShadowLeft * current_zoom_)),
                   static_cast<int>(ceil(kPageShadowTop * current_zoom_)),
@@ skipping 22 matching lines @@
     if (range.page_index() != page_index)
       continue;
 
     std::vector<pp::Rect> rects = range.GetScreenRects(
         visible_rect.point(), current_zoom_, current_rotation_);
     for (const auto& rect : rects) {
       pp::Rect visible_selection = rect.Intersect(dirty_in_screen);
       if (visible_selection.IsEmpty())
         continue;
 
-      visible_selection.Offset(
-          -dirty_in_screen.point().x(), -dirty_in_screen.point().y());
+      visible_selection.Offset(-dirty_in_screen.point().x(),
+                               -dirty_in_screen.point().y());
       Highlight(region, stride, visible_selection, &highlighted_rects);
     }
   }
 
   for (const auto& highlight : form_highlights_) {
     pp::Rect visible_selection = highlight.Intersect(dirty_in_screen);
-      if (visible_selection.IsEmpty())
-        continue;
+    if (visible_selection.IsEmpty())
+      continue;
 
-    visible_selection.Offset(
-        -dirty_in_screen.point().x(), -dirty_in_screen.point().y());
+    visible_selection.Offset(-dirty_in_screen.point().x(),
+                             -dirty_in_screen.point().y());
     Highlight(region, stride, visible_selection, &highlighted_rects);
   }
   form_highlights_.clear();
 }
 
 void PDFiumEngine::PaintUnavailablePage(int page_index,
                                         const pp::Rect& dirty,
                                         pp::ImageData* image_data) {
   int start_x, start_y, size_x, size_y;
   GetPDFiumRect(page_index, dirty, &start_x, &start_y, &size_x, &size_y);
@@ skipping 16 matching lines @@
   return -1;
 }
 
 FPDF_BITMAP PDFiumEngine::CreateBitmap(const pp::Rect& rect,
                                        pp::ImageData* image_data) const {
   void* region;
   int stride;
   GetRegion(rect.point(), image_data, &region, &stride);
   if (!region)
     return nullptr;
-  return FPDFBitmap_CreateEx(
-      rect.width(), rect.height(), FPDFBitmap_BGRx, region, stride);
+  return FPDFBitmap_CreateEx(rect.width(), rect.height(), FPDFBitmap_BGRx,
+                             region, stride);
 }
 
-void PDFiumEngine::GetPDFiumRect(
-    int page_index, const pp::Rect& rect, int* start_x, int* start_y,
-    int* size_x, int* size_y) const {
+void PDFiumEngine::GetPDFiumRect(int page_index,
+                                 const pp::Rect& rect,
+                                 int* start_x,
+                                 int* start_y,
+                                 int* size_x,
+                                 int* size_y) const {
   pp::Rect page_rect = GetScreenRect(pages_[page_index]->rect());
   page_rect.Offset(-rect.x(), -rect.y());
 
   *start_x = page_rect.x();
   *start_y = page_rect.y();
   *size_x = page_rect.width();
   *size_y = page_rect.height();
 }
 
 int PDFiumEngine::GetRenderingFlags() const {
@@ skipping 13 matching lines @@
   rv.set_y(static_cast<int>(position_.y() / current_zoom_));
   rv.set_width(static_cast<int>(ceil(plugin_size_.width() / current_zoom_)));
   rv.set_height(static_cast<int>(ceil(plugin_size_.height() / current_zoom_)));
   return rv;
 }
 
 pp::Rect PDFiumEngine::GetPageScreenRect(int page_index) const {
   // Since we use this rect for creating the PDFium bitmap, also include other
   // areas around the page that we might need to update such as the page
   // separator and the sides if the page is narrower than the document.
-  return GetScreenRect(pp::Rect(
-      0,
-      pages_[page_index]->rect().y() - kPageShadowTop,
-      document_size_.width(),
-      pages_[page_index]->rect().height() + kPageShadowTop +
-          kPageShadowBottom + kPageSeparatorThickness));
+  return GetScreenRect(
+      pp::Rect(0, pages_[page_index]->rect().y() - kPageShadowTop,
+               document_size_.width(),
+               pages_[page_index]->rect().height() + kPageShadowTop +
+                   kPageShadowBottom + kPageSeparatorThickness));
 }
 
 pp::Rect PDFiumEngine::GetScreenRect(const pp::Rect& rect) const {
   pp::Rect rv;
   int right =
       static_cast<int>(ceil(rect.right() * current_zoom_ - position_.x()));
   int bottom =
-    static_cast<int>(ceil(rect.bottom() * current_zoom_ - position_.y()));
+      static_cast<int>(ceil(rect.bottom() * current_zoom_ - position_.y()));
 
   rv.set_x(static_cast<int>(rect.x() * current_zoom_ - position_.x()));
   rv.set_y(static_cast<int>(rect.y() * current_zoom_ - position_.y()));
   rv.set_width(right - rv.x());
   rv.set_height(bottom - rv.y());
   return rv;
 }
 
 void PDFiumEngine::Highlight(void* buffer,
                              int stride,
@@ skipping 17 matching lines @@
       uint8_t* pixel = static_cast<uint8_t*>(buffer) + y * stride + x * 4;
       //  This is our highlight color.
       pixel[0] = static_cast<uint8_t>(pixel[0] * (kHighlightColorB / 255.0));
       pixel[1] = static_cast<uint8_t>(pixel[1] * (kHighlightColorG / 255.0));
       pixel[2] = static_cast<uint8_t>(pixel[2] * (kHighlightColorR / 255.0));
     }
   }
 }
 
 PDFiumEngine::SelectionChangeInvalidator::SelectionChangeInvalidator(
-    PDFiumEngine* engine) : engine_(engine) {
+    PDFiumEngine* engine)
+    : engine_(engine) {
   previous_origin_ = engine_->GetVisibleRect().point();
   GetVisibleSelectionsScreenRects(&old_selections_);
 }
 
 PDFiumEngine::SelectionChangeInvalidator::~SelectionChangeInvalidator() {
   // Offset the old selections if the document scrolled since we recorded them.
   pp::Point offset = previous_origin_ - engine_->GetVisibleRect().point();
   for (auto& old_selection : old_selections_)
     old_selection.Offset(offset);
 
@@ skipping 23 matching lines @@
 
 void PDFiumEngine::SelectionChangeInvalidator::GetVisibleSelectionsScreenRects(
     std::vector<pp::Rect>* rects) {
   pp::Rect visible_rect = engine_->GetVisibleRect();
   for (auto& range : engine_->selection_) {
     int page_index = range.page_index();
     if (!engine_->IsPageVisible(page_index))
       continue;  // This selection is on a page that's not currently visible.
 
     std::vector<pp::Rect> selection_rects =
-        range.GetScreenRects(
-            visible_rect.point(),
-            engine_->current_zoom_,
-            engine_->current_rotation_);
+        range.GetScreenRects(visible_rect.point(), engine_->current_zoom_,
+                             engine_->current_rotation_);
     rects->insert(rects->end(), selection_rects.begin(), selection_rects.end());
   }
 }
 
 PDFiumEngine::MouseDownState::MouseDownState(
     const PDFiumPage::Area& area,
     const PDFiumPage::LinkTarget& target)
-    : area_(area), target_(target) {
-}
+    : area_(area), target_(target) {}
 
-PDFiumEngine::MouseDownState::~MouseDownState() {
-}
+PDFiumEngine::MouseDownState::~MouseDownState() {}
 
 void PDFiumEngine::MouseDownState::Set(const PDFiumPage::Area& area,
                                        const PDFiumPage::LinkTarget& target) {
   area_ = area;
   target_ = target;
 }
 
 void PDFiumEngine::MouseDownState::Reset() {
   area_ = PDFiumPage::NONSELECTABLE_AREA;
   target_ = PDFiumPage::LinkTarget();
 }
 
 bool PDFiumEngine::MouseDownState::Matches(
     const PDFiumPage::Area& area,
     const PDFiumPage::LinkTarget& target) const {
   if (area_ != area)
     return false;
 
   if (area == PDFiumPage::WEBLINK_AREA)
     return target_.url == target.url;
 
   if (area == PDFiumPage::DOCLINK_AREA)
     return target_.page == target.page;
 
   return true;
 }
 
-PDFiumEngine::FindTextIndex::FindTextIndex()
-    : valid_(false), index_(0) {
-}
+PDFiumEngine::FindTextIndex::FindTextIndex() : valid_(false), index_(0) {}
 
-PDFiumEngine::FindTextIndex::~FindTextIndex() {
-}
+PDFiumEngine::FindTextIndex::~FindTextIndex() {}
 
 void PDFiumEngine::FindTextIndex::Invalidate() {
   valid_ = false;
 }
 
 size_t PDFiumEngine::FindTextIndex::GetIndex() const {
   DCHECK(valid_);
   return index_;
 }
 
 void PDFiumEngine::FindTextIndex::SetIndex(size_t index) {
   valid_ = true;
   index_ = index;
 }
 
 size_t PDFiumEngine::FindTextIndex::IncrementIndex() {
   DCHECK(valid_);
   return ++index_;
 }
 
 void PDFiumEngine::DeviceToPage(int page_index,
                                 float device_x,
                                 float device_y,
                                 double* page_x,
                                 double* page_y) {
   *page_x = *page_y = 0;
   int temp_x = static_cast<int>((device_x + position_.x()) / current_zoom_ -
-      pages_[page_index]->rect().x());
+                                pages_[page_index]->rect().x());
   int temp_y = static_cast<int>((device_y + position_.y()) / current_zoom_ -
-      pages_[page_index]->rect().y());
-  FPDF_DeviceToPage(
-      pages_[page_index]->GetPage(), 0, 0,
-      pages_[page_index]->rect().width(),  pages_[page_index]->rect().height(),
-      current_rotation_, temp_x, temp_y, page_x, page_y);
+                                pages_[page_index]->rect().y());
+  FPDF_DeviceToPage(pages_[page_index]->GetPage(), 0, 0,
+                    pages_[page_index]->rect().width(),
+                    pages_[page_index]->rect().height(), current_rotation_,
+                    temp_x, temp_y, page_x, page_y);
 }
 
 int PDFiumEngine::GetVisiblePageIndex(FPDF_PAGE page) {
   for (int page_index : visible_pages_) {
     if (pages_[page_index]->GetPage() == page)
       return page_index;
   }
   return -1;
 }
 
 void PDFiumEngine::SetCurrentPage(int index) {
   in_flight_visible_page_.reset();
 
   if (index == most_visible_page_ || !form_)
     return;
 
   if (most_visible_page_ != -1 && called_do_document_action_) {
     FPDF_PAGE old_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(old_page, form_, FPDFPAGE_AACTION_CLOSE);
   }
   most_visible_page_ = index;
 #if defined(OS_LINUX)
-    g_last_instance_id = client_->GetPluginInstance()->pp_instance();
+  g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
   if (most_visible_page_ != -1 && called_do_document_action_) {
     FPDF_PAGE new_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(new_page, form_, FPDFPAGE_AACTION_OPEN);
   }
 }
 
 void PDFiumEngine::TransformPDFPageForPrinting(
     FPDF_PAGE page,
     const PP_PrintSettings_Dev& print_settings) {
   // Get the source page width and height in points.
   const double src_page_width = FPDF_GetPageWidth(page);
   const double src_page_height = FPDF_GetPageHeight(page);
 
   const int src_page_rotation = FPDFPage_GetRotation(page);
   const bool fit_to_page = print_settings.print_scaling_option ==
-      PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA;
+                           PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA;
 
   pp::Size page_size(print_settings.paper_size);
   pp::Rect content_rect(print_settings.printable_area);
   const bool rotated = (src_page_rotation % 2 == 1);
-  SetPageSizeAndContentRect(rotated,
-                            src_page_width > src_page_height,
-                            &page_size,
-                            &content_rect);
+  SetPageSizeAndContentRect(rotated, src_page_width > src_page_height,
+                            &page_size, &content_rect);
 
   // Compute the screen page width and height in points.
   const int actual_page_width =
       rotated ? page_size.height() : page_size.width();
   const int actual_page_height =
       rotated ? page_size.width() : page_size.height();
 
-  const gfx::Rect gfx_content_rect(content_rect.x(),
-                                   content_rect.y(),
-                                   content_rect.width(),
-                                   content_rect.height());
-  const double scale_factor = fit_to_page ?
-      printing::CalculateScaleFactor(
-          gfx_content_rect, src_page_width, src_page_height, rotated) : 1.0;
+  const gfx::Rect gfx_content_rect(content_rect.x(), content_rect.y(),
+                                   content_rect.width(), content_rect.height());
+  const double scale_factor =
+      fit_to_page
+          ? printing::CalculateScaleFactor(gfx_content_rect, src_page_width,
+                                           src_page_height, rotated)
+          : 1.0;
 
   // Calculate positions for the clip box.
   printing::PdfRectangle media_box;
   printing::PdfRectangle crop_box;
-  bool has_media_box = !!FPDFPage_GetMediaBox(page,
-                                              &media_box.left,
-                                              &media_box.bottom,
-                                              &media_box.right,
-                                              &media_box.top);
-  bool has_crop_box = !!FPDFPage_GetCropBox(page,
-                                            &crop_box.left,
-                                            &crop_box.bottom,
-                                            &crop_box.right,
-                                            &crop_box.top);
-  printing::CalculateMediaBoxAndCropBox(
-      rotated, has_media_box, has_crop_box, &media_box, &crop_box);
+  bool has_media_box =
+      !!FPDFPage_GetMediaBox(page, &media_box.left, &media_box.bottom,
+                             &media_box.right, &media_box.top);
+  bool has_crop_box = !!FPDFPage_GetCropBox(
+      page, &crop_box.left, &crop_box.bottom, &crop_box.right, &crop_box.top);
+  printing::CalculateMediaBoxAndCropBox(rotated, has_media_box, has_crop_box,
+                                        &media_box, &crop_box);
   printing::PdfRectangle source_clip_box =
       printing::CalculateClipBoxBoundary(media_box, crop_box);
   printing::ScalePdfRectangle(scale_factor, &source_clip_box);
 
   // Calculate the translation offset values.
   double offset_x = 0;
   double offset_y = 0;
   if (fit_to_page) {
-    printing::CalculateScaledClipBoxOffset(
-        gfx_content_rect, source_clip_box, &offset_x, &offset_y);
+    printing::CalculateScaledClipBoxOffset(gfx_content_rect, source_clip_box,
+                                           &offset_x, &offset_y);
   } else {
     printing::CalculateNonScaledClipBoxOffset(
-        gfx_content_rect, src_page_rotation,
-        actual_page_width, actual_page_height,
-        source_clip_box, &offset_x, &offset_y);
+        gfx_content_rect, src_page_rotation, actual_page_width,
+        actual_page_height, source_clip_box, &offset_x, &offset_y);
   }
 
   // Reset the media box and crop box. When the page has crop box and media box,
   // the plugin will display the crop box contents and not the entire media box.
   // If the pages have different crop box values, the plugin will display a
   // document of multiple page sizes. To give better user experience, we
   // decided to have same crop box and media box values. Hence, the user will
   // see a list of uniform pages.
   FPDFPage_SetMediaBox(page, 0, 0, page_size.width(), page_size.height());
   FPDFPage_SetCropBox(page, 0, 0, page_size.width(), page_size.height());
 
   // Transformation is not required, return. Do this check only after updating
   // the media box and crop box. For more detailed information, please refer to
   // the comment block right before FPDF_SetMediaBox and FPDF_GetMediaBox calls.
   if (scale_factor == 1.0 && offset_x == 0 && offset_y == 0)
     return;
 
-
   // All the positions have been calculated, now manipulate the PDF.
   FS_MATRIX matrix = {static_cast<float>(scale_factor),
                       0,
                       0,
                       static_cast<float>(scale_factor),
                       static_cast<float>(offset_x),
                       static_cast<float>(offset_y)};
-  FS_RECTF cliprect = {static_cast<float>(source_clip_box.left+offset_x),
-                       static_cast<float>(source_clip_box.top+offset_y),
-                       static_cast<float>(source_clip_box.right+offset_x),
-                       static_cast<float>(source_clip_box.bottom+offset_y)};
+  FS_RECTF cliprect = {static_cast<float>(source_clip_box.left + offset_x),
+                       static_cast<float>(source_clip_box.top + offset_y),
+                       static_cast<float>(source_clip_box.right + offset_x),
+                       static_cast<float>(source_clip_box.bottom + offset_y)};
   FPDFPage_TransFormWithClip(page, &matrix, &cliprect);
-  FPDFPage_TransformAnnots(page, scale_factor, 0, 0, scale_factor,
-                           offset_x, offset_y);
+  FPDFPage_TransformAnnots(page, scale_factor, 0, 0, scale_factor, offset_x,
+                           offset_y);
 }
 
 void PDFiumEngine::DrawPageShadow(const pp::Rect& page_rc,
                                   const pp::Rect& shadow_rc,
                                   const pp::Rect& clip_rc,
                                   pp::ImageData* image_data) {
   pp::Rect page_rect(page_rc);
   page_rect.Offset(page_offset_);
 
   pp::Rect shadow_rect(shadow_rc);
   shadow_rect.Offset(page_offset_);
 
   pp::Rect clip_rect(clip_rc);
   clip_rect.Offset(page_offset_);
 
   // Page drop shadow parameters.
   const double factor = 0.5;
   uint32_t depth =
       std::max(std::max(page_rect.x() - shadow_rect.x(),
                         page_rect.y() - shadow_rect.y()),
                std::max(shadow_rect.right() - page_rect.right(),
                         shadow_rect.bottom() - page_rect.bottom()));
   depth = static_cast<uint32_t>(depth * 1.5) + 1;
 
   // We need to check depth only to verify our copy of shadow matrix is correct.
   if (!page_shadow_.get() || page_shadow_->depth() != depth)
-    page_shadow_.reset(new ShadowMatrix(depth, factor,
-                                        client_->GetBackgroundColor()));
+    page_shadow_.reset(
+        new ShadowMatrix(depth, factor, client_->GetBackgroundColor()));
 
   DCHECK(!image_data->is_null());
   DrawShadow(image_data, shadow_rect, page_rect, clip_rect, *page_shadow_);
 }
 
 void PDFiumEngine::GetRegion(const pp::Point& location,
                              pp::ImageData* image_data,
                              void** region,
                              int* stride) const {
   if (image_data->is_null()) {
@@ skipping 266 matching lines @@
 }
 
 int PDFiumEngine::Form_Response(IPDF_JSPLATFORM* param,
                                 FPDF_WIDESTRING question,
                                 FPDF_WIDESTRING title,
                                 FPDF_WIDESTRING default_response,
                                 FPDF_WIDESTRING label,
                                 FPDF_BOOL password,
                                 void* response,
                                 int length) {
-  std::string question_str = base::UTF16ToUTF8(
-      reinterpret_cast<const base::char16*>(question));
+  std::string question_str =
+      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(question));
   std::string default_str = base::UTF16ToUTF8(
       reinterpret_cast<const base::char16*>(default_response));
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   std::string rv = engine->client_->Prompt(question_str, default_str);
   base::string16 rv_16 = base::UTF8ToUTF16(rv);
   int rv_bytes = rv_16.size() * sizeof(base::char16);
   if (response) {
     int bytes_to_copy = rv_bytes < length ? rv_bytes : length;
     memcpy(response, rv_16.c_str(), bytes_to_copy);
@@ skipping 55 matching lines @@
 void PDFiumEngine::Form_SubmitForm(IPDF_JSPLATFORM* param,
                                    void* form_data,
                                    int length,
                                    FPDF_WIDESTRING url) {
   std::string url_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->SubmitForm(url_str, form_data, length);
 }
 
-void PDFiumEngine::Form_GotoPage(IPDF_JSPLATFORM* param,
-                                 int page_number) {
+void PDFiumEngine::Form_GotoPage(IPDF_JSPLATFORM* param, int page_number) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->ScrollToPage(page_number);
 }
 
 int PDFiumEngine::Form_Browse(IPDF_JSPLATFORM* param,
                               void* file_path,
                               int length) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   std::string path = engine->client_->ShowFileSelectionDialog();
   if (path.size() + 1 <= static_cast<size_t>(length))
     memcpy(file_path, &path[0], path.size() + 1);
   return path.size() + 1;
 }
 
 FPDF_BOOL PDFiumEngine::Pause_NeedToPauseNow(IFSDK_PAUSE* param) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  return (base::Time::Now() - engine->last_progressive_start_time_).
-      InMilliseconds() > engine->progressive_paint_timeout_;
+  return (base::Time::Now() - engine->last_progressive_start_time_)
+             .InMilliseconds() > engine->progressive_paint_timeout_;
 }
 
 ScopedUnsupportedFeature::ScopedUnsupportedFeature(PDFiumEngine* engine)
     : old_engine_(g_engine_for_unsupported) {
   g_engine_for_unsupported = engine;
 }
 
 ScopedUnsupportedFeature::~ScopedUnsupportedFeature() {
   g_engine_for_unsupported = old_engine_;
 }
 
 ScopedSubstFont::ScopedSubstFont(PDFiumEngine* engine)
     : old_engine_(g_engine_for_fontmapper) {
   g_engine_for_fontmapper = engine;
 }
 
 ScopedSubstFont::~ScopedSubstFont() {
   g_engine_for_fontmapper = old_engine_;
 }
 
 namespace {
 
 base::LazyInstance<PDFiumEngineExports>::Leaky g_pdf_engine_exports =
     LAZY_INSTANCE_INITIALIZER;
 
 int CalculatePosition(FPDF_PAGE page,
                       const PDFiumEngineExports::RenderingSettings& settings,
                       pp::Rect* dest) {
-  int page_width = static_cast<int>(ConvertUnitDouble(FPDF_GetPageWidth(page),
-                                                      kPointsPerInch,
-                                                      settings.dpi_x));
-  int page_height = static_cast<int>(ConvertUnitDouble(FPDF_GetPageHeight(page),
-                                                       kPointsPerInch,
-                                                       settings.dpi_y));
+  int page_width = static_cast<int>(ConvertUnitDouble(
+      FPDF_GetPageWidth(page), kPointsPerInch, settings.dpi_x));
+  int page_height = static_cast<int>(ConvertUnitDouble(
+      FPDF_GetPageHeight(page), kPointsPerInch, settings.dpi_y));
 
   // Start by assuming that we will draw exactly to the bounds rect
   // specified.
   *dest = settings.bounds;
 
   int rotate = 0;  // normal orientation.
 
   // Auto-rotate landscape pages to print correctly.
   if (settings.autorotate &&
       (dest->width() > dest->height()) != (page_width > page_height)) {
@@ skipping 100 matching lines @@
                     settings.bounds.y() + settings.bounds.height());
 
   // A "temporary" hack. Some PDFs seems to render very slowly if
   // FPDF_RenderPage() is directly used on a printer DC. I suspect it is
   // because of the code to talk Postscript directly to the printer if
   // the printer supports this. Need to discuss this with PDFium. For now,
   // render to a bitmap and then blit the bitmap to the DC if we have been
   // supplied a printer DC.
   int device_type = GetDeviceCaps(dc, TECHNOLOGY);
   if (device_type == DT_RASPRINTER || device_type == DT_PLOTTER) {
-    FPDF_BITMAP bitmap = FPDFBitmap_Create(dest.width(), dest.height(),
-                                           FPDFBitmap_BGRx);
-      // Clear the bitmap
+    FPDF_BITMAP bitmap =
+        FPDFBitmap_Create(dest.width(), dest.height(), FPDFBitmap_BGRx);
+    // Clear the bitmap
     FPDFBitmap_FillRect(bitmap, 0, 0, dest.width(), dest.height(), 0xFFFFFFFF);
-    FPDF_RenderPageBitmap(
-        bitmap, page, 0, 0, dest.width(), dest.height(), rotate,
-        FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
+    FPDF_RenderPageBitmap(bitmap, page, 0, 0, dest.width(), dest.height(),
+                          rotate, FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
     int stride = FPDFBitmap_GetStride(bitmap);
     BITMAPINFO bmi;
     memset(&bmi, 0, sizeof(bmi));
     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
     bmi.bmiHeader.biWidth = dest.width();
     bmi.bmiHeader.biHeight = -dest.height();  // top-down image
     bmi.bmiHeader.biPlanes = 1;
     bmi.bmiHeader.biBitCount = 32;
     bmi.bmiHeader.biCompression = BI_RGB;
     bmi.bmiHeader.biSizeImage = stride * dest.height();
-    StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(),
-                  0, 0, dest.width(), dest.height(),
-                  FPDFBitmap_GetBuffer(bitmap), &bmi, DIB_RGB_COLORS, SRCCOPY);
+    StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(), 0, 0,
+                  dest.width(), dest.height(), FPDFBitmap_GetBuffer(bitmap),
+                  &bmi, DIB_RGB_COLORS, SRCCOPY);
     FPDFBitmap_Destroy(bitmap);
   } else {
     FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(),
                     rotate, FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   }
   RestoreDC(dc, save_state);
   FPDF_ClosePage(page);
   FPDF_CloseDocument(doc);
   return true;
 }
 
 void PDFiumEngineExports::SetPDFEnsureTypefaceCharactersAccessible(
     PDFEnsureTypefaceCharactersAccessible func) {
   FPDF_SetTypefaceAccessibleFunc(
       reinterpret_cast<PDFiumEnsureTypefaceCharactersAccessible>(func));
 }
 
 void PDFiumEngineExports::SetPDFUseGDIPrinting(bool enable) {
   FPDF_SetPrintTextWithGDI(enable);
 }
 
-void PDFiumEngineExports::SetPDFPostscriptPrintingLevel(
-    int postscript_level) {
+void PDFiumEngineExports::SetPDFPostscriptPrintingLevel(int postscript_level) {
   FPDF_SetPrintPostscriptLevel(postscript_level);
 }
 
 #endif  // defined(OS_WIN)
 
 bool PDFiumEngineExports::RenderPDFPageToBitmap(
     const void* pdf_buffer,
     int pdf_buffer_size,
     int page_number,
     const RenderingSettings& settings,
     void* bitmap_buffer) {
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
   if (!page) {
     FPDF_CloseDocument(doc);
     return false;
   }
 
   pp::Rect dest;
   int rotate = CalculatePosition(page, settings, &dest);
 
-  FPDF_BITMAP bitmap =
-      FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(),
-                          FPDFBitmap_BGRA, bitmap_buffer,
-                          settings.bounds.width() * 4);
+  FPDF_BITMAP bitmap = FPDFBitmap_CreateEx(
+      settings.bounds.width(), settings.bounds.height(), FPDFBitmap_BGRA,
+      bitmap_buffer, settings.bounds.width() * 4);
   // Clear the bitmap
   FPDFBitmap_FillRect(bitmap, 0, 0, settings.bounds.width(),
                       settings.bounds.height(), 0xFFFFFFFF);
   // Shift top-left corner of bounds to (0, 0) if it's not there.
   dest.set_point(dest.point() - settings.bounds.point());
-  FPDF_RenderPageBitmap(
-      bitmap, page, dest.x(), dest.y(), dest.width(), dest.height(), rotate,
-      FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
+  FPDF_RenderPageBitmap(bitmap, page, dest.x(), dest.y(), dest.width(),
+                        dest.height(), rotate,
+                        FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   FPDFBitmap_Destroy(bitmap);
   FPDF_ClosePage(page);
   FPDF_CloseDocument(doc);
   return true;
 }
 
 bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer,
                                         int buffer_size,
                                         int* page_count,
                                         double* max_page_width) {
@@ skipping 27 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf