Clang format pdf/

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 30 matching lines @@
       first_paint_(true),
       view_size_changed_waiting_for_paint_(false) {
   // Set the callback object outside of the initializer list to avoid a
   // compiler warning about using "this" in an initializer list.
   callback_factory_.Initialize(this);
 
   // You can not use a NULL client pointer.
   DCHECK(client);
 }
 
-PaintManager::~PaintManager() {
-}
+PaintManager::~PaintManager() {}
 
 // static
 pp::Size PaintManager::GetNewContextSize(const pp::Size& current_context_size,
                                          const pp::Size& plugin_size) {
   // The amount of additional space in pixels to allocate to the right/bottom of
   // the context.
   const int kBufferSize = 50;
 
   // Default to returning the same size.
   pp::Size result = current_context_size;
 
   // The minimum size of the plugin before resizing the context to ensure we
   // aren't wasting too much memory. We deduct twice the kBufferSize from the
   // current context size which gives a threshhold that is kBufferSize below
   // the plugin size when the context size was last computed.
   pp::Size min_size(
       std::max(current_context_size.width() - 2 * kBufferSize, 0),
       std::max(current_context_size.height() - 2 * kBufferSize, 0));
 
   // If the plugin size is bigger than the current context size, we need to
   // resize the context. If the plugin size is smaller than the current
   // context size by a given threshhold then resize the context so that we
   // aren't wasting too much memory.
   if (plugin_size.width() > current_context_size.width() ||
       plugin_size.height() > current_context_size.height() ||
       plugin_size.width() < min_size.width() ||
       plugin_size.height() < min_size.height()) {
-      // Create a larger context than needed so that if we only resize by a
-      // small margin, we don't need a new context.
-      result = pp::Size(plugin_size.width() + kBufferSize,
-                        plugin_size.height() + kBufferSize);
+    // Create a larger context than needed so that if we only resize by a
+    // small margin, we don't need a new context.
+    result = pp::Size(plugin_size.width() + kBufferSize,
+                      plugin_size.height() + kBufferSize);
   }
 
   return result;
 }
 
 void PaintManager::Initialize(pp::Instance* instance,
                               Client* client,
                               bool is_always_opaque) {
   DCHECK(!instance_ && !client_);  // Can't initialize twice.
   instance_ = instance;
@@ skipping 87 matching lines @@
   // don't have to do anything differently now.
   if (flush_pending_)
     return;
 
   // If no flush is pending, we need to do a manual call to get back to the
   // main thread. We may have one already pending, or we may need to schedule.
   if (manual_callback_pending_)
     return;
 
   pp::Module::Get()->core()->CallOnMainThread(
-      0,
-      callback_factory_.NewCallback(&PaintManager::OnManualCallbackComplete),
+      0, callback_factory_.NewCallback(&PaintManager::OnManualCallbackComplete),
       0);
   manual_callback_pending_ = true;
 }
 
 void PaintManager::DoPaint() {
   in_paint_ = true;
 
   std::vector<ReadyRect> ready_rects;
   std::vector<pp::Rect> pending_rects;
 
@@ skipping 71 matching lines @@
     aggregator_.SetIntermediateResults(ready_later, pending_rects);
 
     if (ready_now.empty()) {
       in_paint_ = false;
       EnsureCallbackPending();
       return;
     }
   }
 
   for (const auto& ready_rect : ready_now) {
-    graphics_.PaintImageData(
-        ready_rect.image_data, ready_rect.offset, ready_rect.rect);
+    graphics_.PaintImageData(ready_rect.image_data, ready_rect.offset,
+                             ready_rect.rect);
   }
 
   Flush();
 
   in_paint_ = false;
   first_paint_ = false;
 
   if (graphics_need_to_be_bound_) {
     instance_->BindGraphics(graphics_);
     graphics_need_to_be_bound_ = false;
@@ 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();
 }