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 68 matching lines @@
     // TODO(sammiequon): Investigate if we should stop (which removes all
     // 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);
+  // Do not add the point but advance the time if the view is in process of
+  // fading away.
+  if (is_fading_away_)
+    laser_points_.MoveForwardInTime();
+  else
+    laser_points_.AddPoint(new_point);
 
   // 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::SetIsFadingAway(bool is_fading) {
+  is_fading_away_ = is_fading;
+}
+
+bool LaserPointerView::GetIsFadingAway() const {
+  return is_fading_away_;
+}
+
 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();
+
+  base::Time oldest = laser_points_.GetCollectionEarliestTime();
+  base::Time newest = laser_points_.GetCollectionLatestTime();
+  gfx::Vector2d previous_point_vector =
+      laser_points_.GetOldest().location - widget_offset;
+  gfx::Point previous_point =
+      gfx::Point(previous_point_vector.x(), previous_point_vector.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;
+    double relative_time = 0.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, relative_time);
+    current_opacity =
+        int{LinearInterpolate(double{kPointInitialOpacity},
+                              double{kPointFinalOpacity}, relative_time)};
 
     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