Another round of PDF plugin cleanups.

pdf/paint_manager.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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 193 matching lines @@
   client_->OnPaint(update.paint_rects, &ready, &pending);
 
   if (ready.empty() && pending.empty()) {
     in_paint_ = false;
     return;  // Nothing was painted, don't schedule a flush.
   }
 
   std::vector<PaintAggregator::ReadyRect> ready_now;
   if (pending.empty()) {
     std::vector<PaintAggregator::ReadyRect> temp_ready;
-    for (size_t i = 0; i < ready.size(); ++i)
-      temp_ready.push_back(ready[i]);
+    temp_ready.insert(temp_ready.end(), ready.begin(), ready.end());
     aggregator_.SetIntermediateResults(temp_ready, pending);
     ready_now = aggregator_.GetReadyRects();
     aggregator_.ClearPendingUpdate();
 
     // Apply any scroll first.
     if (update.has_scroll)
       graphics_.Scroll(update.scroll_rect, update.scroll_delta);
 
     view_size_changed_waiting_for_paint_ = false;
   } else {
     std::vector<PaintAggregator::ReadyRect> ready_later;
-    for (size_t i = 0; i < ready.size(); ++i) {
+    for (const auto& ready_rect : ready) {
       // Don't flush any part (i.e. scrollbars) if we're resizing the browser,
       // as that'll lead to flashes.  Until we flush, the browser will use the
       // previous image, but if we flush, it'll revert to using the blank image.
       // We make an exception for the first paint since we want to show the
       // default background color instead of the pepper default of black.
-      if (ready[i].flush_now &&
+      if (ready_rect.flush_now &&
           (!view_size_changed_waiting_for_paint_ || first_paint_)) {
-        ready_now.push_back(ready[i]);
+        ready_now.push_back(ready_rect);
       } else {
-        ready_later.push_back(ready[i]);
+        ready_later.push_back(ready_rect);
       }
     }
     // Take the rectangles, except the ones that need to be flushed right away,
     // and save them so that everything is flushed at once.
     aggregator_.SetIntermediateResults(ready_later, pending);
 
     if (ready_now.empty()) {
       in_paint_ = false;
       EnsureCallbackPending();
       return;
     }
   }
 
-  for (size_t i = 0; i < ready_now.size(); ++i) {
+  for (const auto& ready_rect : ready_now) {
     graphics_.PaintImageData(
-        ready_now[i].image_data, ready_now[i].offset, ready_now[i].rect);
+        ready_rect.image_data, ready_rect.offset, ready_rect.rect);
   }
 
   int32_t result = graphics_.Flush(
       callback_factory_.NewCallback(&PaintManager::OnFlushComplete));
 
   // If you trigger this assertion, then your plugin has called Flush()
   // manually. When using the PaintManager, you should not call Flush, it will
   // handle that for you because it needs to know when it can do the next paint
   // by implementing the flush callback.
   //
@@ skipping 32 matching lines @@
   DCHECK(manual_callback_pending_);
   manual_callback_pending_ = false;
 
   // Just because we have a manual callback doesn't mean there are actually any
   // invalid regions. Even though we only schedule this callback when something
   // is pending, a Flush callback could have come in before this callback was
   // executed and that could have cleared the queue.
   if (aggregator_.HasPendingUpdate())
     DoPaint();
 }