PDF Viewer pinch zoom: Update state for zoom in following a zoom out.

pdf/out_of_process_instance.cc

 // Copyright (c) 2012 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/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>  // for min/max()
@@ skipping 402 matching lines @@
     stop_scrolling_ = false;
     PinchPhase pinch_phase =
         static_cast<PinchPhase>(dict.Get(pp::Var(kJSPinchPhase)).AsInt());
     double zoom = dict.Get(pp::Var(kJSZoom)).AsDouble();
     double zoom_ratio = zoom / zoom_;
 
     pp::FloatPoint scroll_offset(dict.Get(pp::Var(kJSXOffset)).AsDouble(),
                                  dict.Get(pp::Var(kJSYOffset)).AsDouble());
 
     if (pinch_phase == PINCH_START) {
-      starting_scroll_offset_ = scroll_offset;
-      initial_zoom_ratio_ = zoom_ratio;
+      scroll_offset_at_last_raster_ = scroll_offset;
       last_bitmap_smaller_ = false;
       needs_reraster_ = false;
       return;
     }
 
     // When zooming in, we set a layer transform to avoid unneeded rerasters.
     // Also, if we're zooming out and the last time we rerastered was when
     // we were even further zoomed out (i.e. we pinch zoomed in and are now
     // pinch zooming back out in the same gesture), we update the layer
     // transform instead of rerastering.
@@ skipping 18 matching lines @@
       // If the rendered document doesn't fill the display area we will
       // use |paint_offset| to anchor the paint vertically into the same place.
       // We use the scroll bars instead of the pinch vector to get the actual
       // position on screen of the paint.
       pp::Point paint_offset;
 
       if (plugin_size_.width() > GetDocumentPixelWidth() * zoom_ratio) {
         // We want to keep the paint in the middle but it must stay in the same
         // position relative to the scroll bars.
         paint_offset = pp::Point(0, (1 - zoom_ratio) * pinch_center.y());
-        scroll_delta = pp::Point(0,
-            (scroll_offset.y() -
-             starting_scroll_offset_.y() * zoom_ratio / initial_zoom_ratio_));
+        scroll_delta =
+            pp::Point(0, (scroll_offset.y() -
+                          scroll_offset_at_last_raster_.y() * zoom_ratio));
 
         pinch_vector = pp::Point();
         last_bitmap_smaller_ = true;
       } else if (last_bitmap_smaller_) {
           pinch_center = pp::Point((plugin_size_.width() / device_scale_) / 2,
               (plugin_size_.height() / device_scale_) / 2);
           const double zoom_when_doc_covers_plugin_width =
               zoom_ * plugin_size_.width() / GetDocumentPixelWidth();
           paint_offset = pp::Point(
               (1 - zoom / zoom_when_doc_covers_plugin_width) * pinch_center.x(),
               (1 - zoom_ratio) * pinch_center.y());
           pinch_vector = pp::Point();
-          scroll_delta = pp::Point(
-              (scroll_offset.x() -
-               starting_scroll_offset_.x() * zoom_ratio / initial_zoom_ratio_),
-              (scroll_offset.y() -
-               starting_scroll_offset_.y() * zoom_ratio / initial_zoom_ratio_));
+          scroll_delta =
+              pp::Point((scroll_offset.x() -
+                         scroll_offset_at_last_raster_.x() * zoom_ratio),
+                        (scroll_offset.y() -
+                         scroll_offset_at_last_raster_.y() * zoom_ratio));
       }
 
       paint_manager_.SetTransform(zoom_ratio, pinch_center,
           pinch_vector + paint_offset + scroll_delta,
           true);
       needs_reraster_ = false;
       return;
     }
 
     if (pinch_phase == PINCH_UPDATE_ZOOM_OUT || pinch_phase == PINCH_END) {
       // We reraster on pinch zoom out in order to solve the invalid regions
       // that appear after zooming out.
       // On pinch end the scale is again 1.f and we request a reraster
       // in the new position.
       paint_manager_.ClearTransform();
       last_bitmap_smaller_ = false;
       needs_reraster_ = true;
+
+      // If we're rerastering due to zooming out, we need to update
+      // |scroll_offset_at_last_raster_|, in case the user continues the
+      // gesture by zooming in.
+      scroll_offset_at_last_raster_ = scroll_offset;
     }
 
     // Bound the input parameters.
     zoom = std::max(kMinZoom, zoom);
     SetZoom(zoom);
     scroll_offset = BoundScrollOffsetToDocument(scroll_offset);
     engine_->ScrolledToXPosition(scroll_offset.x() * device_scale_);
     engine_->ScrolledToYPosition(scroll_offset.y() * device_scale_);
   } else if (type == kJSGetPasswordCompleteType &&
              dict.Get(pp::Var(kJSPassword)).is_string()) {
@@ skipping 1140 matching lines @@
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf