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

ash/laser/laser_pointer_controller.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_controller.h"
 
 #include "ash/common/system/chromeos/palette/palette_utils.h"
 #include "ash/laser/laser_pointer_view.h"
 #include "ash/shell.h"
 #include "ui/aura/window_event_dispatcher.h"
@@ skipping 55 matching lines @@
 
   if (event->pointer_details().pointer_type !=
       ui::EventPointerType::POINTER_TYPE_PEN)
     return;
 
   if (event->type() != ui::ET_MOUSE_DRAGGED &&
       event->type() != ui::ET_MOUSE_PRESSED &&
       event->type() != ui::ET_MOUSE_RELEASED)
     return;
 
-  // Delete the LaserPointerView instance if mouse is released.
-  if (event->type() == ui::ET_MOUSE_RELEASED) {
-    stationary_timer_->Stop();
-    laser_pointer_view_->Stop();
-    laser_pointer_view_.reset();
+  aura::Window* current_window = GetCurrentRootWindow();
+
+  if (!current_window) {
+    DestroyLaserPointerView();
     return;
   }
 
-  // This will handle creating the initial laser pointer view on
-  // ET_MOUSE_PRESSED events.
-  SwitchTargetRootWindowIfNeeded(GetCurrentRootWindow());
+  // Compute the event coordinate relative to the display it is currently on
+  // (and not the one the event was captured on).
+  gfx::Point event_location = event->root_location();
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  aura::Window* event_root = target->GetRootWindow();
+  aura::Window::ConvertPointToTarget(event_root, current_window,
+                                     &event_location);
+
+  // Do not start a new laser session if the event is over the palette, or is in
+  // process of fading away.
+  if (!laser_pointer_view_ &&
+      (is_fading_away_ || PaletteContainsPointInScreen(event_location))) {

[jdufault, 2016/10/13 00:12:30]

We should allow a new session even if the laser is fading away.

For example, if the user lifts the stylus up off the screen for a brief second
and puts it down before the laser has finished fading away, then they will not
have a laser pointer until lifting up and pressing down again.

When is the expression (!laser_pointer_view_ && is_fading_away_) true?

[sammiequon, 2016/10/14 18:48:50]

Yeah that expression never happens, so it was working as expected previously.

+    return;
+  }
+
+  // If the stylus is pressed and the laser pointer view is currently active,
+  // create a new view.
+  if (event->type() == ui::ET_MOUSE_PRESSED)
+    DestroyLaserPointerView();
+
+  SwitchTargetRootWindowIfNeeded(current_window);

[jdufault, 2016/10/13 00:12:30]

I think this code would be much easier if the implicit state machine was made
more explicit. For example:

  if (!enabled_)
    return;
  if (!event_is_not_pen)
    return;
  if (!current_window) {
    DestroyLaserPointerView();
    return;
  }

  if (event_type_is_down && !OverStylusTools()) {
    // The Laser could still be fading away from a previous event sequence.
    DestroyLaserPointerView();
    ShowLaserPointer()
    event->StopPropagation()
  }

  if (event_type_is_move && laser_pointer_view_) {
    ChangeLaserPointerWidgetIfNeeded();
    laser_pointer_view->AddNewPoint(current_mouse_location_);
    stationary_timer_repeat_count_ = 0;
    event->StopPropagation()
  }

  if (event_type_is_up) {
    laser_pointer_view->UpdateTime();
    stationary_timer_repeat_count_ = 0;
    is_fading_away_ = true;
    event->StopPropagation()
  }


The event->StopPropagation calls can be deduped by moving the three ifs into a
helper function that returns true if the event was handled, ie,

  if (UpdateLaserView(event))
    event->StopPropagation()

I'm not convinced that is worthwhile since it is only one statement.

[sammiequon, 2016/10/14 18:48:50]

Done.

 
   if (laser_pointer_view_) {
-    // Remap point from where it was captured to the display it is actually on.
-    gfx::Point event_location = event->root_location();
-    aura::Window* target = static_cast<aura::Window*>(event->target());
-    aura::Window* event_root = target->GetRootWindow();
-    aura::Window::ConvertPointToTarget(
-        event_root, laser_pointer_view_->GetRootWindow(), &event_location);
-
     current_mouse_location_ = event_location;
-    laser_pointer_view_->AddNewPoint(current_mouse_location_);
+    // Signal the view to start fading away if the mouse has been released.
+    is_fading_away_ = event->type() == ui::ET_MOUSE_RELEASED;
+    if (is_fading_away_)
+      laser_pointer_view_->UpdateTime();
+    else
+      laser_pointer_view_->AddNewPoint(current_mouse_location_);
 
     stationary_timer_repeat_count_ = 0;
-    if (event->type() == ui::ET_MOUSE_DRAGGED) {
-      // Start the timer to add stationary points if dragged.
+    if (event->type() == ui::ET_MOUSE_DRAGGED ||
+        event->type() == ui::ET_MOUSE_RELEASED) {
+      // Start the timer to add stationary points if dragged, or to advance the
+      // internal collections timestamps if released.
       if (!stationary_timer_->IsRunning())
         stationary_timer_->Reset();
     }
-
-    // If the stylus is over the palette icon or widget, do not consume the
-    // event.
-    if (!PaletteContainsPointInScreen(current_mouse_location_))
-      event->StopPropagation();
   }
+  event->StopPropagation();
 }
 
 void LaserPointerController::OnWindowDestroying(aura::Window* window) {
   SwitchTargetRootWindowIfNeeded(window);
 }
 
 void LaserPointerController::SwitchTargetRootWindowIfNeeded(
     aura::Window* root_window) {
   if (!root_window) {
-    stationary_timer_->Stop();
-    laser_pointer_view_.reset();
+    DestroyLaserPointerView();
   } else if (laser_pointer_view_) {
     laser_pointer_view_->ReparentWidget(root_window);
   } else if (enabled_) {
     laser_pointer_view_.reset(new LaserPointerView(
         base::TimeDelta::FromMilliseconds(kPointLifeDurationMs), root_window));
   }
 }
 
+void LaserPointerController::DestroyLaserPointerView() {
+  // |stationary_timer_| should also be stopped so that it does not attempt to
+  // add points when |laser_pointer_view_| is null.
+  stationary_timer_->Stop();
+  if (laser_pointer_view_) {
+    is_fading_away_ = false;
+    laser_pointer_view_.reset();
+  }
+}
+
 void LaserPointerController::AddStationaryPoint() {
-  laser_pointer_view_->AddNewPoint(current_mouse_location_);
+  if (is_fading_away_)
+    laser_pointer_view_->UpdateTime();
+  else
+    laser_pointer_view_->AddNewPoint(current_mouse_location_);
+
   // We can stop repeating the timer once the mouse has been stationary for
   // longer than the life of a point.
   if (stationary_timer_repeat_count_ * kAddStationaryPointsDelayMs >=
       kPointLifeDurationMs) {
     stationary_timer_->Stop();
+    // Reset the view if the timer expires and the view was in process of fading
+    // away.
+    if (is_fading_away_)
+      DestroyLaserPointerView();
   }
   stationary_timer_repeat_count_++;
 }
 }  // namespace ash