Another round of PDF plugin cleanups.

pdf/out_of_process_instance.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>  // for min/max()
@@ skipping 684 matching lines @@
     pp::Rect rect = pp::Rect(pp::Point(), image_data_.size());
     FillRect(rect, background_color_);
     ready->push_back(PaintManager::ReadyRect(rect, image_data_, true));
   }
 
   if (!received_viewport_message_)
     return;
 
   engine_->PrePaint();
 
-  for (size_t i = 0; i < paint_rects.size(); i++) {
+  for (const auto& paint_rect : paint_rects) {
     // Intersect with plugin area since there could be pending invalidates from
     // when the plugin area was larger.
     pp::Rect rect =
-        paint_rects[i].Intersect(pp::Rect(pp::Point(), plugin_size_));
+        paint_rect.Intersect(pp::Rect(pp::Point(), plugin_size_));
     if (rect.IsEmpty())
       continue;
 
     pp::Rect pdf_rect = available_area_.Intersect(rect);
     if (!pdf_rect.IsEmpty()) {
       pdf_rect.Offset(available_area_.x() * -1, 0);
 
       std::vector<pp::Rect> pdf_ready;
       std::vector<pp::Rect> pdf_pending;
       engine_->Paint(pdf_rect, &image_data_, &pdf_ready, &pdf_pending);
-      for (size_t j = 0; j < pdf_ready.size(); ++j) {
-        pdf_ready[j].Offset(available_area_.point());
+      for (auto& ready_rect : pdf_ready) {
+        ready_rect.Offset(available_area_.point());
         ready->push_back(
-            PaintManager::ReadyRect(pdf_ready[j], image_data_, false));
+            PaintManager::ReadyRect(ready_rect, image_data_, false));
       }
-      for (size_t j = 0; j < pdf_pending.size(); ++j) {
-        pdf_pending[j].Offset(available_area_.point());
-        pending->push_back(pdf_pending[j]);
+      for (auto& pending_rect : pdf_pending) {
+        pending_rect.Offset(available_area_.point());
+        pending->push_back(pending_rect);
       }
     }
 
     // Ensure the region above the first page (if any) is filled;
     int32_t first_page_ypos = engine_->GetNumberOfPages() == 0 ?
         0 : engine_->GetPageScreenRect(0).y();
     if (rect.y() < first_page_ypos) {
       pp::Rect region = rect.Intersect(pp::Rect(
           pp::Point(), pp::Size(plugin_size_.width(), first_page_ypos)));
       ready->push_back(PaintManager::ReadyRect(region, image_data_, false));
       FillRect(region, background_color_);
     }
 
-    for (size_t j = 0; j < background_parts_.size(); ++j) {
-      pp::Rect intersection = background_parts_[j].location.Intersect(rect);
+    for (const auto& background_part : background_parts_) {
+      pp::Rect intersection = background_part.location.Intersect(rect);
       if (!intersection.IsEmpty()) {
-        FillRect(intersection, background_parts_[j].color);
+        FillRect(intersection, background_part.color);
         ready->push_back(
             PaintManager::ReadyRect(intersection, image_data_, false));
       }
     }
   }
 
   engine_->PostPaint();
 }
 
 void OutOfProcessInstance::DidOpen(int32_t result) {
@@ skipping 160 matching lines @@
   }
 
   cursor_interface->SetCursor(
       pp_instance(), cursor_, pp::ImageData().pp_resource(), nullptr);
 }
 
 void OutOfProcessInstance::UpdateTickMarks(
     const std::vector<pp::Rect>& tickmarks) {
   float inverse_scale = 1.0f / device_scale_;
   std::vector<pp::Rect> scaled_tickmarks = tickmarks;
-  for (size_t i = 0; i < scaled_tickmarks.size(); i++)
-    ScaleRect(inverse_scale, &scaled_tickmarks[i]);
+  for (auto& tickmark : scaled_tickmarks)
+    ScaleRect(inverse_scale, &tickmark);
   tickmarks_ = scaled_tickmarks;
 }
 
 void OutOfProcessInstance::NotifyNumberOfFindResultsChanged(int total,
                                                             bool final_result) {
   // We don't want to spam the renderer with too many updates to the number of
   // find results. Don't send an update if we sent one too recently. If it's the
   // final update, we always send it though.
   if (final_result) {
     NumberOfFindResultsChanged(total, final_result);
@@ skipping 499 matching lines @@
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf