Another round of PDF plugin cleanups.

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 591 matching lines @@
   IPDF_JSPLATFORM::Doc_submitForm = Form_SubmitForm;
   IPDF_JSPLATFORM::Doc_gotoPage = Form_GotoPage;
   IPDF_JSPLATFORM::Field_browse = Form_Browse;
 
   IFSDK_PAUSE::version = 1;
   IFSDK_PAUSE::user = NULL;
   IFSDK_PAUSE::NeedToPauseNow = Pause_NeedToPauseNow;
 }
 
 PDFiumEngine::~PDFiumEngine() {
-  for (size_t i = 0; i < pages_.size(); ++i)
-    pages_[i]->Unload();
+  for (auto& page : pages_)
+    page->Unload();
 
   if (doc_) {
     FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WC);
 
 #ifdef PDF_USE_XFA
     // XFA may require |form_| to outlive |doc_|, so shut down in that order.
     FPDF_CloseDocument(doc_);
     FPDFDOC_ExitFormFillEnvironment(form_);
 #else
     // Normally |doc_| should outlive |form_|.
@@ skipping 251 matching lines @@
   file_wrapper->file_handler.Truncate = Sample_Truncate;
   file_wrapper->file_handler.WriteBlock = Sample_WriteBlock;
 
   return &file_wrapper->file_handler;
 }
 
 FPDF_FILEHANDLER* PDFiumEngine::Form_OpenFile(FPDF_FORMFILLINFO* param,
                                               int file_flag,
                                               FPDF_WIDESTRING url,
                                               const char* mode) {
-  std::string url_str = "NULL";
-  if (url != NULL) {
-    url_str =
-        base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
-  }
+  std::string url_str = url ?
+      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url)) : "NULL";
+
   // TODO: need to implement open file from the url
   // Use a file path for the ease of testing
   FILE* file = fopen(XFA_TESTFILE("tem.txt"), mode);
   FPDF_FILE* file_wrapper = new FPDF_FILE;
   file_wrapper->file = file;
   file_wrapper->file_handler.clientData = file_wrapper;
   file_wrapper->file_handler.Flush = Sample_Flush;
   file_wrapper->file_handler.GetSize = Sample_GetSize;
   file_wrapper->file_handler.ReadBlock = Sample_ReadBlock;
   file_wrapper->file_handler.Release = Sample_Release;
@@ skipping 71 matching lines @@
 void PDFiumEngine::ScrolledToYPosition(int position) {
   CancelPaints();
 
   int old_y = position_.y();
   position_.set_y(position);
   CalculateVisiblePages();
   client_->Scroll(pp::Point(0, old_y - position));
 }
 
 void PDFiumEngine::PrePaint() {
-  for (size_t i = 0; i < progressive_paints_.size(); ++i)
-    progressive_paints_[i].painted_ = false;
+  for (auto& paint : progressive_paints_)
+    paint.painted_ = false;
 }
 
 void PDFiumEngine::Paint(const pp::Rect& rect,
                          pp::ImageData* image_data,
                          std::vector<pp::Rect>* ready,
                          std::vector<pp::Rect>* pending) {
   DCHECK(image_data);
   DCHECK(ready);
   DCHECK(pending);
 
@@ skipping 139 matching lines @@
 void PDFiumEngine::OnPendingRequestComplete() {
   if (!doc_ || !form_) {
     LoadDocument();
     return;
   }
 
   // LoadDocument() will result in |pending_pages_| being reset so there's no
   // need to run the code below in that case.
   bool update_pages = false;
   std::vector<int> still_pending;
-  for (size_t i = 0; i < pending_pages_.size(); ++i) {
-    if (CheckPageAvailable(pending_pages_[i], &still_pending)) {
+  for (int pending_page : pending_pages_) {
+    if (CheckPageAvailable(pending_page, &still_pending)) {
       update_pages = true;
-      if (IsPageVisible(pending_pages_[i]))
-        client_->Invalidate(GetPageScreenRect(pending_pages_[i]));
+      if (IsPageVisible(pending_page))
+        client_->Invalidate(GetPageScreenRect(pending_page));
     }
   }
   pending_pages_.swap(still_pending);
   if (update_pages)
     LoadPageInfo(true);
 }
 
 void PDFiumEngine::OnNewDataAvailable() {
   client_->DocumentLoadProgress(doc_loader_.GetAvailableData(),
                                 doc_loader_.document_size());
@@ skipping 116 matching lines @@
       break;
     case PP_INPUTEVENT_TYPE_CHAR:
       rv = OnChar(pp::KeyboardInputEvent(event));
       break;
     default:
       break;
   }
 
   DCHECK(defer_page_unload_);
   defer_page_unload_ = false;
-  for (size_t i = 0; i < deferred_page_unloads_.size(); ++i)
-    pages_[deferred_page_unloads_[i]]->Unload();
+  for (int page_index : deferred_page_unloads_)
+    pages_[page_index]->Unload();
   deferred_page_unloads_.clear();
   return rv;
 }
 
 uint32_t PDFiumEngine::QuerySupportedPrintOutputFormats() {
   if (!HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return 0;
   return PP_PRINTOUTPUTFORMAT_PDF;
 }
 
@@ skipping 87 matching lines @@
     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;
   // Collect pages to print and sizes of source pages.
   std::vector<uint32_t> page_numbers =
       GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count);
-  for (size_t i = 0; i < page_numbers.size(); ++i) {
-    uint32_t page_number = page_numbers[i];
+  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));
 
     int width_in_pixels = ConvertUnit(source_page_width,
                                       kPointsPerInch,
                                       print_settings.dpi);
     int height_in_pixels = ConvertUnit(source_page_height,
@@ skipping 92 matching lines @@
     if (page_ranges[index].first_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 (size_t i = 0; i < page_numbers.size(); ++i) {
-    uint32_t page_number = page_numbers[i];
+  for (uint32_t page_number : page_numbers) {
     pages_[page_number]->GetPage();
-    if (!IsPageVisible(page_numbers[i]))
+    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);
@@ skipping 42 matching lines @@
 
 PDFiumPage::Area PDFiumEngine::GetCharIndex(const pp::Point& point,
                                             int* page_index,
                                             int* char_index,
                                             int* form_type,
                                             PDFiumPage::LinkTarget* target) {
   int page = -1;
   pp::Point point_in_page(
       static_cast<int>((point.x() + position_.x()) / current_zoom_),
       static_cast<int>((point.y() + position_.y()) / current_zoom_));
-  for (size_t i = 0; i < visible_pages_.size(); ++i) {
-    if (pages_[visible_pages_[i]]->rect().Contains(point_in_page)) {
-      page = visible_pages_[i];
+  for (int visible_page : visible_pages_) {
+    if (pages_[visible_page]->rect().Contains(point_in_page)) {
+      page = visible_page;
       break;
     }
   }
   if (page == -1)
     return PDFiumPage::NONSELECTABLE_AREA;
 
   // If the page hasn't finished rendering, calling into the page sometimes
   // leads to hangs.
-  for (size_t i = 0; i < progressive_paints_.size(); ++i) {
-    if (progressive_paints_[i].page_index == page)
+  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);
 }
 
 bool PDFiumEngine::OnMouseDown(const pp::MouseInputEvent& event) {
   if (event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_RIGHT) {
-    if (!selection_.size())
+    if (selection_.empty())
       return false;
     std::vector<pp::Rect> selection_rect_vector;
     GetAllScreenRectsUnion(&selection_, GetVisibleRect().point(),
                            &selection_rect_vector);
     pp::Point point = event.GetPosition();
-    for (size_t i = 0; i < selection_rect_vector.size(); ++i) {
-      if (selection_rect_vector[i].Contains(point.x(), point.y()))
+    for (const auto& rect : selection_rect_vector) {
+      if (rect.Contains(point.x(), point.y()))
         return false;
     }
     SelectionChangeInvalidator selection_invalidator(this);
     selection_.clear();
     return true;
   }
   if (event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_LEFT)
     return false;
 
   SelectionChangeInvalidator selection_invalidator(this);
@@ skipping 195 matching lines @@
   // Check if the user has descreased their selection area and we need to remove
   // pages from selection_.
   for (size_t i = 0; i < selection_.size(); ++i) {
     if (selection_[i].page_index() == page_index) {
       // There should be no other pages after this.
       selection_.erase(selection_.begin() + i + 1, selection_.end());
       break;
     }
   }
 
-  if (selection_.size() == 0)
+  if (selection_.empty())
     return false;
 
   int last = selection_.size() - 1;
   if (selection_[last].page_index() == page_index) {
     // Selecting within a page.
     int count;
     if (char_index >= selection_[last].char_index()) {
       // Selecting forward.
       count = char_index - selection_[last].char_index() + 1;
     } else {
@@ skipping 235 matching lines @@
       reinterpret_cast<unsigned short*>(api_string_adapter.GetData());
   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);
-  for (size_t i = 0; i < results.size(); ++i) {
+  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 = results[i].start_index + character_to_start_searching_from;
+    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 + results[i].length);
+        temp_start + result.length);
     AddFindResult(PDFiumRange(pages_[current_page], start, end - start));
   }
 }
 
 void PDFiumEngine::AddFindResult(const PDFiumRange& result) {
   // Figure out where to insert the new location, since we could have
   // started searching midway and now we wrapped.
   size_t result_index;
   int page_index = result.page_index();
   int char_index = result.char_index();
@@ skipping 50 matching lines @@
   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;
   rects = find_results_[current_find_index_.GetIndex()].GetScreenRects(
       pp::Point(), 1.0, current_rotation_);
-  for (size_t i = 0; i < rects.size(); ++i)
-    bounding_rect = bounding_rect.Union(rects[i]);
+  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);
     if (new_y < 0)
       new_y = 0;
     client_->ScrollToY(new_y);
 
     // Only move horizontally if it's not visible.
@@ skipping 21 matching lines @@
   last_character_index_to_search_ = -1;
   current_find_index_.Invalidate();
   current_find_text_.clear();
   UpdateTickMarks();
   find_factory_.CancelAll();
 }
 
 void PDFiumEngine::GetAllScreenRectsUnion(std::vector<PDFiumRange>* rect_range,
                                           const pp::Point& offset_point,
                                           std::vector<pp::Rect>* rect_vector) {
-  for (std::vector<PDFiumRange>::iterator it = rect_range->begin();
-       it != rect_range->end(); ++it) {
-    pp::Rect rect;
+  for (auto& range : *rect_range) {
+    pp::Rect result_rect;
     std::vector<pp::Rect> rects =
-        it->GetScreenRects(offset_point, current_zoom_, current_rotation_);
-    for (size_t j = 0; j < rects.size(); ++j)
-      rect = rect.Union(rects[j]);
-    rect_vector->push_back(rect);
+        range.GetScreenRects(offset_point, current_zoom_, current_rotation_);
+    for (const auto& rect : rects)
+      result_rect = result_rect.Union(rect);
+    rect_vector->push_back(result_rect);
   }
 }
 
 void PDFiumEngine::UpdateTickMarks() {
   std::vector<pp::Rect> tickmarks;
   GetAllScreenRectsUnion(&find_results_, pp::Point(0, 0), &tickmarks);
   client_->UpdateTickMarks(tickmarks);
 }
 
 void PDFiumEngine::ZoomUpdated(double new_zoom_level) {
@@ skipping 86 matching lines @@
       return (permissions_ & kPDFPermissionPrintLowQualityMask) != 0;
     default:
       return true;
   }
 }
 
 void PDFiumEngine::SelectAll() {
   SelectionChangeInvalidator selection_invalidator(this);
 
   selection_.clear();
-  for (size_t i = 0; i < pages_.size(); ++i)
-    if (pages_[i]->available()) {
-      selection_.push_back(PDFiumRange(pages_[i], 0,
-                           pages_[i]->GetCharCount()));
-    }
+  for (const auto& page : pages_) {
+    if (page->available())
+      selection_.push_back(PDFiumRange(page, 0, page->GetCharCount()));
+  }
 }
 
 int PDFiumEngine::GetNumberOfPages() {
   return pages_.size();
 }
 
 pp::VarArray PDFiumEngine::GetBookmarks() {
   pp::VarDictionary dict = TraverseBookmarks(doc_, NULL, 0);
   // The root bookmark contains no useful information.
   return pp::VarArray(dict.Get(pp::Var("children")));
@@ skipping 170 matching lines @@
     client_->DocumentLoadFailed();
 }
 
 bool PDFiumEngine::TryLoadingDoc(bool with_password,
                                  const std::string& password,
                                  bool* needs_password) {
   *needs_password = false;
   if (doc_)
     return true;
 
-  const char* password_cstr = NULL;
+  const char* password_cstr = nullptr;
   if (with_password) {
     password_cstr = password.c_str();
     password_tries_remaining_--;
   }
   if (doc_loader_.IsDocumentComplete())
     doc_ = FPDF_LoadCustomDocument(&file_access_, password_cstr);
   else
     doc_ = FPDFAvail_GetDocument(fpdf_availability_, password_cstr);
 
   if (!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD)
     *needs_password = true;
 
-  return doc_ != NULL;
+  return !!doc_;
 }
 
 void PDFiumEngine::GetPasswordAndLoad() {
   getting_password_ = true;
   DCHECK(!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD);
   client_->GetDocumentPassword(password_factory_.NewCallbackWithOutput(
       &PDFiumEngine::OnGetPasswordComplete));
 }
 
 void PDFiumEngine::OnGetPasswordComplete(int32_t result,
@@ skipping 165 matching lines @@
     pp::Rect rc_next =
         visible_rect.Intersect(GetPageScreenRect(most_visible_page + 1));
     if (rc_next.height() > rc_first.height())
       most_visible_page++;
   }
 
   SetCurrentPage(most_visible_page);
 }
 
 bool PDFiumEngine::IsPageVisible(int index) const {
-  for (size_t i = 0; i < visible_pages_.size(); ++i) {
-    if (visible_pages_[i] == index)
-      return true;
-  }
-
-  return false;
+  return ContainsValue(visible_pages_, index);
 }
 
 bool PDFiumEngine::CheckPageAvailable(int index, std::vector<int>* pending) {
   if (!doc_ || !form_)
     return false;
 
   if (static_cast<int>(pages_.size()) > index && pages_[index]->available())
     return true;
 
   if (!FPDFAvail_IsPageAvail(fpdf_availability_, index, &download_hints_)) {
@@ skipping 108 matching lines @@
   DrawSelections(progressive_index, image_data);
 
   FPDF_RenderPage_Close(pages_[page_index]->GetPage());
   FPDFBitmap_Destroy(bitmap);
   progressive_paints_.erase(progressive_paints_.begin() + progressive_index);
 
   client_->DocumentPaintOccurred();
 }
 
 void PDFiumEngine::CancelPaints() {
-  for (size_t i = 0; i < progressive_paints_.size(); ++i) {
-    FPDF_RenderPage_Close(pages_[progressive_paints_[i].page_index]->GetPage());
-    FPDFBitmap_Destroy(progressive_paints_[i].bitmap);
+  for (const auto& paint : progressive_paints_) {
+    FPDF_RenderPage_Close(pages_[paint.page_index]->GetPage());
+    FPDFBitmap_Destroy(paint.bitmap);
   }
   progressive_paints_.clear();
 }
 
 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;
@@ skipping 75 matching lines @@
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
 
   void* region = NULL;
   int stride;
   GetRegion(dirty_in_screen.point(), image_data, &region, &stride);
 
   std::vector<pp::Rect> highlighted_rects;
   pp::Rect visible_rect = GetVisibleRect();
-  for (size_t k = 0; k < selection_.size(); ++k) {
-    if (selection_[k].page_index() != page_index)
+  for (auto& range : selection_) {
+    if (range.page_index() != page_index)
       continue;
-    std::vector<pp::Rect> rects = selection_[k].GetScreenRects(
+
+    std::vector<pp::Rect> rects = range.GetScreenRects(
         visible_rect.point(), current_zoom_, current_rotation_);
-    for (size_t j = 0; j < rects.size(); ++j) {
-      pp::Rect visible_selection = rects[j].Intersect(dirty_in_screen);
+    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());
       Highlight(region, stride, visible_selection, &highlighted_rects);
     }
   }
 
-  for (size_t k = 0; k < form_highlights_.size(); ++k) {
-    pp::Rect visible_selection = form_highlights_[k].Intersect(dirty_in_screen);
+  for (const auto& highlight : form_highlights_) {
+    pp::Rect visible_selection = highlight.Intersect(dirty_in_screen);
       if (visible_selection.IsEmpty())
         continue;
 
     visible_selection.Offset(
         -dirty_in_screen.point().x(), -dirty_in_screen.point().y());
     Highlight(region, stride, visible_selection, &highlighted_rects);
   }
   form_highlights_.clear();
 }
 
@@ skipping 89 matching lines @@
 }
 
 void PDFiumEngine::Highlight(void* buffer,
                              int stride,
                              const pp::Rect& rect,
                              std::vector<pp::Rect>* highlighted_rects) {
   if (!buffer)
     return;
 
   pp::Rect new_rect = rect;
-  for (size_t i = 0; i < highlighted_rects->size(); ++i)
-    new_rect = new_rect.Subtract((*highlighted_rects)[i]);
+  for (const auto& highlighted : *highlighted_rects)
+    new_rect = new_rect.Subtract(highlighted);
 
   highlighted_rects->push_back(new_rect);
   int l = new_rect.x();
   int t = new_rect.y();
   int w = new_rect.width();
   int h = new_rect.height();
 
   for (int y = t; y < t + h; ++y) {
     for (int x = l; x < l + w; ++x) {
       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) {
   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 (size_t i = 0; i < old_selections_.size(); ++i)
-    old_selections_[i].Offset(offset);
+  for (auto& old_selection : old_selections_)
+    old_selection.Offset(offset);
 
   std::vector<pp::Rect> new_selections;
   GetVisibleSelectionsScreenRects(&new_selections);
-  for (size_t i = 0; i < new_selections.size(); ++i) {
-    for (size_t j = 0; j < old_selections_.size(); ++j) {
-      if (!old_selections_[j].IsEmpty() &&
-          new_selections[i] == old_selections_[j]) {
+  for (auto& new_selection : new_selections) {
+    for (auto& old_selection : old_selections_) {
+      if (!old_selection.IsEmpty() && new_selection == old_selection) {
         // Rectangle was selected before and after, so no need to invalidate it.
         // Mark the rectangles by setting them to empty.
-        new_selections[i] = old_selections_[j] = pp::Rect();
+        new_selection = old_selection = pp::Rect();
         break;
       }
     }
   }
 
-  for (size_t i = 0; i < old_selections_.size(); ++i) {
-    if (!old_selections_[i].IsEmpty())
-      engine_->client_->Invalidate(old_selections_[i]);
+  for (const auto& old_selection : old_selections_) {
+    if (!old_selection.IsEmpty())
+      engine_->client_->Invalidate(old_selection);
   }
-  for (size_t i = 0; i < new_selections.size(); ++i) {
-    if (!new_selections[i].IsEmpty())
-      engine_->client_->Invalidate(new_selections[i]);
+  for (const auto& new_selection : new_selections) {
+    if (!new_selection.IsEmpty())
+      engine_->client_->Invalidate(new_selection);
   }
   engine_->OnSelectionChanged();
 }
 
-void
-PDFiumEngine::SelectionChangeInvalidator::GetVisibleSelectionsScreenRects(
+void PDFiumEngine::SelectionChangeInvalidator::GetVisibleSelectionsScreenRects(
     std::vector<pp::Rect>* rects) {
   pp::Rect visible_rect = engine_->GetVisibleRect();
-  for (size_t i = 0; i < engine_->selection_.size(); ++i) {
-    int page_index = engine_->selection_[i].page_index();
+  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 =
-        engine_->selection_[i].GetScreenRects(
+        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)
@@ skipping 10 matching lines @@
 }
 
 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) {
-    if (area == PDFiumPage::WEBLINK_AREA)
-      return target_.url == target.url;
-    if (area == PDFiumPage::DOCLINK_AREA)
-      return target_.page == target.page;
-    return true;
-  }
-  return false;
+  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() {
 }
 
 void PDFiumEngine::FindTextIndex::Invalidate() {
@@ skipping 25 matching lines @@
       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);
 }
 
 int PDFiumEngine::GetVisiblePageIndex(FPDF_PAGE page) {
-  for (size_t i = 0; i < visible_pages_.size(); ++i) {
-    if (pages_[visible_pages_[i]]->GetPage() == page)
-      return visible_pages_[i];
+  for (int page_index : visible_pages_) {
+    if (pages_[page_index]->GetPage() == page)
+      return page_index;
   }
   return -1;
 }
 
 void PDFiumEngine::SetCurrentPage(int index) {
   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);
@@ skipping 728 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf