ash: Add basic prediction code to the laser pointer.

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/ash_switches.h"
 #include "ash/common/system/chromeos/palette/palette_utils.h"
 #include "ash/laser/laser_pointer_view.h"
 #include "ash/shell.h"
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
 #include "ui/display/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // A point gets removed from the collection if it is older than
 // |kPointLifeDurationMs|.
 const int kPointLifeDurationMs = 200;
 
 // When no move events are being received we add a new point every
 // |kAddStationaryPointsDelayMs| so that points older than
 // |kPointLifeDurationMs| can get removed.
 // Note: Using a delay less than the screen refresh interval will not
 // provide a visual benefit but instead just waste time performing
 // unnecessary updates. 16ms is the refresh interval on most devices.
 // TODO(reveman): Use real VSYNC interval instead of a hard-coded delay.
 const int kAddStationaryPointsDelayMs = 16;
 
+// The default amount of time used to estimate time from VSYNC event to when
+// visible light can be noticed by the user. This is used when a device
+// specific estimate was not provided using --estimated-presentation-delay.
+const int kDefaultPresentationDelayMs = 18;
+
 }  // namespace
 
 LaserPointerController::LaserPointerController()
     : stationary_timer_(new base::Timer(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kAddStationaryPointsDelayMs),
           base::Bind(&LaserPointerController::AddStationaryPoint,
                      base::Unretained(this)),
-          true /* is_repeating */)) {
+          true /* is_repeating */)),
+      presentation_delay_(
+          base::TimeDelta::FromMilliseconds(kDefaultPresentationDelayMs)) {
   Shell::GetInstance()->AddPreTargetHandler(this);
+
+  // Use device specific presentation delay if specified.
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kAshEstimatedPresentationDelay)) {

[Daniele Castagna, 2017/03/15 19:07:28]

nit: you can get rid of this line and the code should behave the same way.
If the flag is not passed the string will be "" and StringToInt64 will return
false.

[reveman, 2017/03/16 12:57:28]

Done.

+    std::string presentation_delay_string = command_line->GetSwitchValueASCII(
+        switches::kAshEstimatedPresentationDelay);
+    int64_t presentation_delay_time_ms;
+    if (base::StringToInt64(presentation_delay_string,
+                            &presentation_delay_time_ms)) {
+      presentation_delay_ =
+          base::TimeDelta::FromMilliseconds(presentation_delay_time_ms);
+    }
+  }
 }
 
 LaserPointerController::~LaserPointerController() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void LaserPointerController::SetEnabled(bool enabled) {
   if (enabled == enabled_)
     return;
 
@@ skipping 50 matching lines @@
 }
 
 void LaserPointerController::SwitchTargetRootWindowIfNeeded(
     aura::Window* root_window) {
   if (!root_window) {
     DestroyLaserPointerView();
   }
 
   if (!laser_pointer_view_ && enabled_) {
     laser_pointer_view_.reset(new LaserPointerView(
-        base::TimeDelta::FromMilliseconds(kPointLifeDurationMs), root_window));
+        base::TimeDelta::FromMilliseconds(kPointLifeDurationMs),
+        presentation_delay_, root_window));
   }
 }
 
 void LaserPointerController::UpdateLaserPointerView(
     aura::Window* current_window,
     const gfx::PointF& event_location,
     ui::Event* event) {
   SwitchTargetRootWindowIfNeeded(current_window);
   current_stylus_location_ = event_location;
-  laser_pointer_view_->AddNewPoint(current_stylus_location_);
+  laser_pointer_view_->AddNewPoint(current_stylus_location_,
+                                   event->time_stamp());
   event->StopPropagation();
 }
 
 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::RestartTimer() {
   stationary_timer_repeat_count_ = 0;
   stationary_timer_->Reset();
 }
 
 void LaserPointerController::AddStationaryPoint() {
-  if (is_fading_away_)
+  if (is_fading_away_) {
     laser_pointer_view_->UpdateTime();
-  else
-    laser_pointer_view_->AddNewPoint(current_stylus_location_);
+  } else {
+    laser_pointer_view_->AddNewPoint(current_stylus_location_,
+                                     base::TimeTicks::Now());
+  }
 
   // We can stop repeating the timer once the stylus 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