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>
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 
 PaintManager::PaintManager(pp::Instance* instance,
                            Client* client,
                            bool is_always_opaque)
     : instance_(instance),
       client_(client),
       is_always_opaque_(is_always_opaque),
       callback_factory_(NULL),
       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 46 matching lines @@
   DCHECK(!instance_ && !client_);  // Can't initialize twice.
   instance_ = instance;
   client_ = client;
   is_always_opaque_ = is_always_opaque;
 }
 
 void PaintManager::SetSize(const pp::Size& new_size, float device_scale) {
   if (GetEffectiveSize() == new_size &&
       GetEffectiveDeviceScale() == device_scale)
     return;
-
   has_pending_resize_ = true;
   pending_size_ = new_size;
   pending_device_scale_ = device_scale;
 
   view_size_changed_waiting_for_paint_ = true;
+  Invalidate();
+}
 
-  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(
+        callback_factory_.NewCallback(&PaintManager::OnFlushComplete));
+    scale_ = 1.f;
+    origin_ = pp::Point();
+    transform_ = pp::Point();
+  } 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_);
 
   if (graphics_.is_null() && !has_pending_resize_)
     return;
 
   // Clip the rect to the device area.
   pp::Rect clipped_rect = rect.Intersect(pp::Rect(GetEffectiveSize()));
   if (clipped_rect.IsEmpty())
     return;  // Nothing to do.
 
   EnsureCallbackPending();
   aggregator_.InvalidateRect(clipped_rect);
 }
 
 void PaintManager::ScrollRect(const pp::Rect& clip_rect,
                               const pp::Point& amount) {
   DCHECK(!in_paint_);
-

[wjmaclean, 2016/04/21 14:11:02]

Undo white space changes.

[alessandroa, 2016/04/22 14:33:05]

Done.

   if (graphics_.is_null() && !has_pending_resize_)
     return;
 
   EnsureCallbackPending();
 
   aggregator_.ScrollRect(clip_rect, amount);
 }
 
 pp::Size PaintManager::GetEffectiveSize() const {
   return has_pending_resize_ ? pending_size_ : plugin_size_;
@@ skipping 17 matching lines @@
 
   pp::Module::Get()->core()->CallOnMainThread(
       0,
       callback_factory_.NewCallback(&PaintManager::OnManualCallbackComplete),
       0);
   manual_callback_pending_ = true;
 }
 
 void PaintManager::DoPaint() {
   in_paint_ = true;
-

[wjmaclean, 2016/04/21 14:11:02]

Ditto.

[alessandroa, 2016/04/22 14:33:05]

Done.

   std::vector<ReadyRect> ready;
   std::vector<pp::Rect> pending;
 
   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_;
     // Only create a new graphics context if the current context isn't big
     // enough or if it is far too big. This avoids creating a new context if
     // we only resize by a small amount.
     pp::Size new_size = GetNewContextSize(graphics_.size(), pending_size_);
     if (graphics_.size() != new_size) {
       graphics_ = pp::Graphics2D(instance_, new_size, is_always_opaque_);
       graphics_need_to_be_bound_ = true;
 
       // Since we're binding a new one, all of the callbacks have been canceled.
       manual_callback_pending_ = false;
       flush_pending_ = false;
       callback_factory_.CancelAll();
     }
 
-    if (pending_device_scale_ != 1.0)
+    if (pending_device_scale_ != device_scale_)

[bokan, 2016/04/21 18:20:17]

Is this related to the pinch zoom functionality or is this an unrelated fix?

[alessandroa, 2016/04/22 14:33:05]

Reverted :) 

       graphics_.SetScale(1.0 / pending_device_scale_);
+

[wjmaclean, 2016/04/21 14:11:02]

Remove blank line.

[alessandroa, 2016/04/22 14:33:05]

Done.

     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();
-  }
+   }

[wjmaclean, 2016/04/21 14:11:02]

Undo this change ...

[alessandroa, 2016/04/22 14:33:05]

Done.

 
   PaintAggregator::PaintUpdate update = aggregator_.GetPendingUpdate();
   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;
@@ skipping 32 matching lines @@
       in_paint_ = false;
       EnsureCallbackPending();
       return;
     }
   }
 
   for (const auto& ready_rect : ready_now) {
     graphics_.PaintImageData(
         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.
   //
   // Another possible cause of this assertion is re-using devices. If you
   // use one device, swap it with another, then swap it back, we won't know
   // that we've already scheduled a Flush on the first device. It's best to not
   // re-use devices in this way.
   DCHECK(result != PP_ERROR_INPROGRESS);
 
   if (result == PP_OK_COMPLETIONPENDING) {
     flush_pending_ = true;
   } else {
     DCHECK(result == PP_OK);  // Catch all other errors in debug mode.
   }
 
   in_paint_ = false;
   first_paint_ = false;
 
   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(
+        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();
 }