Turn on enforce-in-pdf Clang plugin flag.

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>
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 
+PaintManager::ReadyRect::ReadyRect() = default;
+
+PaintManager::ReadyRect::ReadyRect(const pp::Rect& r,
+                                   const pp::ImageData& i,
+                                   bool f)
+    : rect(r), image_data(i), flush_now(f) {}
+
+PaintManager::ReadyRect::ReadyRect(const ReadyRect& that) = default;
+
 PaintManager::PaintManager(pp::Instance* instance,
                            Client* client,
                            bool is_always_opaque)
     : instance_(instance),
       client_(client),
       is_always_opaque_(is_always_opaque),
-      callback_factory_(NULL),
+      callback_factory_(nullptr),
       manual_callback_pending_(false),
       flush_pending_(false),
       has_pending_resize_(false),
       graphics_need_to_be_bound_(false),
       pending_device_scale_(1.0),
       device_scale_(1.0),
       in_paint_(false),
       first_paint_(true),
       view_size_changed_waiting_for_paint_(false) {
   // Set the callback object outside of the initializer list to avoid a
@@ skipping 123 matching lines @@
   pp::Module::Get()->core()->CallOnMainThread(
       0,
       callback_factory_.NewCallback(&PaintManager::OnManualCallbackComplete),
       0);
   manual_callback_pending_ = true;
 }
 
 void PaintManager::DoPaint() {
   in_paint_ = true;
 
-  std::vector<ReadyRect> ready;
-  std::vector<pp::Rect> pending;
+  std::vector<ReadyRect> ready_rects;
+  std::vector<pp::Rect> pending_rects;
 
   DCHECK(aggregator_.HasPendingUpdate());
 
   // Apply any pending resize. Setting the graphics to this class must happen
   // before asking the plugin to paint in case it requests invalides or resizes.
   // However, the bind must not happen until afterward since we don't want to
   // have an unpainted device bound. The needs_binding flag tells us whether to
   // do this later.
   if (has_pending_resize_) {
     plugin_size_ = pending_size_;
@@ skipping 15 matching lines @@
       graphics_.SetScale(1.0 / pending_device_scale_);
     device_scale_ = pending_device_scale_;
 
     // This must be cleared before calling into the plugin since it may do
     // additional invalidation or sizing operations.
     has_pending_resize_ = false;
     pending_size_ = pp::Size();
   }
 
   PaintAggregator::PaintUpdate update = aggregator_.GetPendingUpdate();
-  client_->OnPaint(update.paint_rects, &ready, &pending);
+  client_->OnPaint(update.paint_rects, &ready_rects, &pending_rects);
 
-  if (ready.empty() && pending.empty()) {
+  if (ready_rects.empty() && pending_rects.empty()) {
     in_paint_ = false;
     return;  // Nothing was painted, don't schedule a flush.
   }
 
   std::vector<PaintAggregator::ReadyRect> ready_now;
-  if (pending.empty()) {
+  if (pending_rects.empty()) {
     std::vector<PaintAggregator::ReadyRect> temp_ready;
-    temp_ready.insert(temp_ready.end(), ready.begin(), ready.end());
-    aggregator_.SetIntermediateResults(temp_ready, pending);
+    temp_ready.insert(temp_ready.end(), ready_rects.begin(), ready_rects.end());
+    aggregator_.SetIntermediateResults(temp_ready, pending_rects);
     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 (const auto& ready_rect : ready) {
+    for (const auto& ready_rect : ready_rects) {
       // 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_rect.flush_now &&
           (!view_size_changed_waiting_for_paint_ || first_paint_)) {
         ready_now.push_back(ready_rect);
       } else {
         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);
+    aggregator_.SetIntermediateResults(ready_later, pending_rects);
 
     if (ready_now.empty()) {
       in_paint_ = false;
       EnsureCallbackPending();
       return;
     }
   }
 
   for (const auto& ready_rect : ready_now) {
     graphics_.PaintImageData(
@@ skipping 43 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();
 }