ash: Improve laser pointer prediction calculations at stylus down.

ash/laser/laser_pointer_view.cc

 // Copyright 2016 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 "ash/laser/laser_pointer_view.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 276 matching lines @@
   gfx::Vector2dF scale(1.0f / screen_size.width(), 1.0f / screen_size.height());
 
   // TODO(reveman): Determine interval based on history when event time stamps
   // are accurate. b/36137953
   const float kPredictionIntervalMs = 5.0f;
   const float kMaxPointIntervalMs = 10.0f;
   base::TimeDelta prediction_interval =
       base::TimeDelta::FromMilliseconds(kPredictionIntervalMs);
   base::TimeDelta max_point_interval =
       base::TimeDelta::FromMilliseconds(kMaxPointIntervalMs);
-  base::TimeTicks last_point_time = current_time;
+  base::TimeTicks last_point_time = new_time;
+  gfx::PointF last_point_location =
+      gfx::ScalePoint(new_point, scale.x(), scale.y());
 
   // Use the last four points for prediction.
   using PositionArray = std::array<gfx::PointF, 4>;
   PositionArray position;
   PositionArray::iterator it = position.begin();
   for (const auto& point : base::Reversed(laser_points_.laser_points())) {
     // Stop adding positions if interval between points is too large to provide
     // an accurate history for prediction.
     if ((last_point_time - point.time) > max_point_interval)
       break;
 
-    *it++ = gfx::ScalePoint(point.location, scale.x(), scale.y());
     last_point_time = point.time;
+    last_point_location = gfx::ScalePoint(point.location, scale.x(), scale.y());
+    *it++ = last_point_location;
 
     // Stop when no more positions are needed.
     if (it == position.end())
       break;
   }
   // Pad with last point if needed.
-  std::fill(it, position.end(), *(it - 1));
+  std::fill(it, position.end(), last_point_location);
 
   // Note: Currently there's no need to divide by the time delta between
   // points as we assume a constant delta between points that matches the
   // prediction point interval.
   gfx::Vector2dF velocity[3];
   for (size_t i = 0; i < arraysize(velocity); ++i)
     velocity[i] = position[i] - position[i + 1];
 
   gfx::Vector2dF acceleration[2];
   for (size_t i = 0; i < arraysize(acceleration); ++i)
@@ skipping 384 matching lines @@
   pending_draw_surface_ = true;
 }
 
 void LaserPointerView::OnDidDrawSurface() {
   pending_draw_surface_ = false;
   if (needs_update_surface_)
     UpdateSurface();
 }
 
 }  // namespace ash