Improved Pinch-Zoom for 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 14 matching lines @@
 
 PaintManager::PaintManager(pp::Instance* instance,
                            Client* client,
                            bool is_always_opaque)
     : instance_(instance),
       client_(client),
       is_always_opaque_(is_always_opaque),
       callback_factory_(nullptr),
       manual_callback_pending_(false),
       flush_pending_(false),
+      flush_requested_(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
   // compiler warning about using "this" in an initializer list.
   callback_factory_.Initialize(this);
@@ skipping 56 matching lines @@
 
   has_pending_resize_ = true;
   pending_size_ = new_size;
   pending_device_scale_ = device_scale;
 
   view_size_changed_waiting_for_paint_ = true;
 
   Invalidate();
 }
 
+void PaintManager::SetTransform(float scale,
+                                pp::Point origin,
+                                pp::Point translate) {
+  if (!flush_pending_) {
+    graphics_.SetLayerTransform(scale, origin, translate);
+    flush_pending_ = true;
+    flush_requested_ = false;
+    graphics_.Flush(

[Kevin McNee - google account, 2016/10/24 15:57:55]

Use the return value of Flush to determine how to set flush_pending_.

[Kevin McNee - google account, 2016/10/24 21:11:47]

Done.

+        callback_factory_.NewCallback(&PaintManager::OnFlushComplete));
+    scale_ = 1.f;
+    origin_ = pp::Point();
+    transform_ = pp::Point();

[Kevin McNee - google account, 2016/10/24 15:57:55]

Not used.

[Kevin McNee - google account, 2016/10/24 21:11:47]

Done.

+  } else {
+    flush_requested_ = true;
+    graphics_.SetLayerTransform(scale, origin, translate);
+  }
+}
+
+void PaintManager::SetTransform(float scale) {
+  graphics_.SetLayerTransform(scale, pp::Point(), pp::Point());
+
+  EnsureCallbackPending();
+}
+
 void PaintManager::Invalidate() {
   if (graphics_.is_null() && !has_pending_resize_)
     return;
 
   EnsureCallbackPending();
   aggregator_.InvalidateRect(pp::Rect(GetEffectiveSize()));
 }
 
 void PaintManager::InvalidateRect(const pp::Rect& rect) {
   DCHECK(!in_paint_);
@@ skipping 166 matching lines @@
   if (graphics_need_to_be_bound_) {
     instance_->BindGraphics(graphics_);
     graphics_need_to_be_bound_ = false;
   }
 }
 
 void PaintManager::OnFlushComplete(int32_t) {
   DCHECK(flush_pending_);
   flush_pending_ = false;
 
+  // If there was another flush request while flushing we flush again.
+  if (flush_requested_) {
+    flush_requested_ = false;
+    graphics_.Flush(

[Kevin McNee - google account, 2016/10/24 15:57:55]

See above wrt calling Flush.

[Kevin McNee - google account, 2016/10/24 21:11:47]

Done.

+        callback_factory_.NewCallback(&PaintManager::OnFlushComplete));
+  }
+
   // If more paints were enqueued while we were waiting for the flush to
   // complete, execute them now.
   if (aggregator_.HasPendingUpdate())
     DoPaint();
 }
 
 void PaintManager::OnManualCallbackComplete(int32_t) {
   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();
 }