Another round of PDF plugin cleanups.

pdf/paint_aggregator.cc

 // Copyright (c) 2010 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/paint_aggregator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 87 matching lines @@
   // Convert the internal paint update to the external one, which includes a
   // bit more precomputed info for the caller.
   PaintUpdate ret;
   ret.scroll_delta = update_.scroll_delta;
   ret.scroll_rect = update_.scroll_rect;
   ret.has_scroll = ret.scroll_delta.x() != 0 || ret.scroll_delta.y() != 0;
 
   // Include the scroll damage (if any) in the paint rects.
   // Code invalidates damaged rect here, it pick it up from the list of paint
   // rects in the next block.
-  if (ret.has_scroll  && !update_.synthesized_scroll_damage_rect_) {
+  if (ret.has_scroll && !update_.synthesized_scroll_damage_rect_) {
     update_.synthesized_scroll_damage_rect_ = true;
     pp::Rect scroll_damage = update_.GetScrollDamage();
     InvalidateRectInternal(scroll_damage, false);
   }
 
   ret.paint_rects.reserve(update_.paint_rects.size() + 1);
-  for (size_t i = 0; i < update_.paint_rects.size(); i++)
-    ret.paint_rects.push_back(update_.paint_rects[i]);
+  ret.paint_rects.insert(ret.paint_rects.end(), update_.paint_rects.begin(),
+                         update_.paint_rects.end());
 
   return ret;
 }
 
 void PaintAggregator::SetIntermediateResults(
     const std::vector<ReadyRect>& ready,
     const std::vector<pp::Rect>& pending) {
   update_.ready_rects.insert(
       update_.ready_rects.end(), ready.begin(), ready.end());
   update_.paint_rects = pending;
@@ skipping 83 matching lines @@
 
     update_.paint_rects[i] = ScrollPaintRect(intersection, amount);
 
     // The rect may have been scrolled out of view.
     if (update_.paint_rects[i].IsEmpty()) {
       update_.paint_rects.erase(update_.paint_rects.begin() + i);
       i--;
     }
   }
 
-  for (size_t i = 0; i < leftover_rects.size(); ++i)
-    InvalidateRectInternal(leftover_rects[i], false);
+  for (const auto& leftover_rect : leftover_rects)
+    InvalidateRectInternal(leftover_rect, false);
 
-  for (size_t i = 0; i < update_.ready_rects.size(); ++i) {
-    if (update_.scroll_rect.Contains(update_.ready_rects[i].rect)) {
-      update_.ready_rects[i].rect =
-          ScrollPaintRect(update_.ready_rects[i].rect, amount);
-    }
+  for (auto& update_rect : update_.ready_rects) {
+    if (update_.scroll_rect.Contains(update_rect.rect))
+      update_rect.rect = ScrollPaintRect(update_rect.rect, amount);
   }
 
   if (update_.synthesized_scroll_damage_rect_) {
     pp::Rect damage = update_.GetScrollDamage();
     InvalidateRect(damage);
   }
 }
 
 pp::Rect PaintAggregator::ScrollPaintRect(const pp::Rect& paint_rect,
                                           const pp::Point& amount) const {
@@ skipping 46 matching lines @@
   }
 
   // If the new paint overlaps with a scroll, then also invalidate the rect in
   // its new position.
   if (check_scroll &&
       !update_.scroll_rect.IsEmpty() &&
       update_.scroll_rect.Intersects(rect)) {
     InvalidateRectInternal(ScrollPaintRect(rect, update_.scroll_delta), false);
   }
 }