cros: Laser pointer fades out on release, do not cover palette.

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 <memory>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/laser/laser_pointer_points.h"
@@ skipping 69 matching lines @@
     // points) or keep the old points. See http://crbug.com/647793.
     Stop();
     views::Widget::ReparentNativeView(
         widget_->GetNativeView(),
         Shell::GetContainer(new_root_window, kShellWindowId_OverlayContainer));
   }
 }
 
 void LaserPointerView::AddNewPoint(const gfx::Point& new_point) {
   laser_points_.AddPoint(new_point);
+  OnPointsUpdated();
+}
 
+void LaserPointerView::UpdateTime() {
+  // Do not add the point but advance the time if the view is in process of
+  // fading away.
+  laser_points_.MoveForwardToTime(base::Time::Now());
+  OnPointsUpdated();
+}
+
+void LaserPointerView::OnPointsUpdated() {
   // The bounding box should be relative to the screen.
   gfx::Point screen_offset =
       widget_->GetNativeView()->GetRootWindow()->GetBoundsInScreen().origin();
 
   // Expand the bounding box so that it includes the radius of the points on the
   // edges.
   gfx::Rect bounding_box;
   bounding_box = laser_points_.GetBoundingBox();
   bounding_box.Offset(-kPointInitialRadius, -kPointInitialRadius);
   bounding_box.Offset(screen_offset.x(), screen_offset.y());
   bounding_box.set_width(bounding_box.width() + (kPointInitialRadius * 2));
   bounding_box.set_height(bounding_box.height() + (kPointInitialRadius * 2));
   widget_->SetBounds(bounding_box);
   SchedulePaint();
 }
 
 void LaserPointerView::OnPaint(gfx::Canvas* canvas) {
   if (laser_points_.IsEmpty())
     return;
 
   SkPaint paint;
   paint.setStyle(SkPaint::kStroke_Style);
   paint.setAntiAlias(true);
   paint.setStrokeJoin(SkPaint::kBevel_Join);
 
-  base::Time oldest = laser_points_.GetOldest().creation_time;
-  base::Time newest = laser_points_.GetNewest().creation_time;
-  gfx::Point previous_point = laser_points_.GetOldest().location;
-  gfx::Point current_point;
-
   // Compute the offset of the current widget.
   gfx::Point widget_offset =
       widget_->GetNativeView()->GetBoundsInRootWindow().origin();
+
+  gfx::Point previous_point(
+      (laser_points_.GetOldest().location - widget_offset).x(),
+      (laser_points_.GetOldest().location - widget_offset).y());
+  gfx::Point current_point;
+
   int num_points_ = laser_points_.GetNumberOfPoints();
   int point_count = 0;
+  int current_opacity = 0;
   for (const LaserPointerPoints::LaserPoint& point :
        laser_points_.laser_points()) {
-    // relative_time is a value between [0,1] where 0 means the point is about
-    // to be removed and 1 means that the point was just added.
-    double relative_time = 1.0;
-    if (oldest != newest) {
-      relative_time = 1.0 - ((point.creation_time - oldest).InMillisecondsF() /
-                             (newest - oldest).InMillisecondsF());
-    }
-
     // Set the radius and opacity based on the distance.
-    double radius = LinearInterpolate(kPointInitialRadius, kPointFinalRadius,
-                                      relative_time);
+    double current_radius =
+        LinearInterpolate(kPointInitialRadius, kPointFinalRadius, point.age);
+    current_opacity = int{LinearInterpolate(
+        double{kPointInitialOpacity}, double{kPointFinalOpacity}, point.age)};
 
     gfx::Vector2d center = point.location - widget_offset;
     current_point = gfx::Point(center.x(), center.y());
 
     // If we draw laser_points_ that are within a stroke width of each other,
     // the result will be very jagged, unless we are on the last point, then we
     // draw regardless.
     point_count++;
-    float distance_threshold = float{radius * 2};
+    float distance_threshold = float{current_radius * 2};
     if (DistanceBetweenPoints(previous_point, current_point) <=
             distance_threshold &&
         point_count != num_points_) {
       continue;
     }
 
-    int opacity =
-        int{LinearInterpolate(double{kPointInitialOpacity},
-                              double{kPointFinalOpacity}, relative_time)};
-    paint.setColor(SkColorSetA(kPointColor, opacity));
-    paint.setStrokeWidth(radius * 2);
+    paint.setColor(SkColorSetA(kPointColor, current_opacity));
+    paint.setStrokeWidth(current_radius * 2);
     canvas->DrawLine(previous_point, current_point, paint);
     previous_point = current_point;
   }
   // Draw the last point as a circle.
-  paint.setColor(SkColorSetA(kPointColor, kPointInitialOpacity));
+  paint.setColor(SkColorSetA(kPointColor, current_opacity));
   paint.setStyle(SkPaint::kFill_Style);
   canvas->DrawCircle(current_point, kPointInitialRadius, paint);
 }
 }  // namespace ash