Pass ui::LatencyInfo correct with unified gesture detector on Aura.

ui/aura/gestures/gesture_recognizer_unittest.cc

 // Copyright (c) 2012 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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 120 matching lines @@
     scroll_y_ = 0;
     scroll_velocity_x_ = 0;
     scroll_velocity_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
     scroll_x_hint_ = 0;
     scroll_y_hint_ = 0;
     tap_count_ = 0;
     scale_ = 0;
     flags_ = 0;
+    latency_info_.Clear();
   }
 
   const std::vector<ui::EventType>& events() const { return events_; };
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool tap_cancel() const { return tap_cancel_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
   bool scroll_begin() const { return scroll_begin_; }
@@ skipping 29 matching lines @@
   float scroll_velocity_x() const { return scroll_velocity_x_; }
   float scroll_velocity_y() const { return scroll_velocity_y_; }
   float velocity_x() const { return velocity_x_; }
   float velocity_y() const { return velocity_y_; }
   float scroll_x_hint() const { return scroll_x_hint_; }
   float scroll_y_hint() const { return scroll_y_hint_; }
   float scale() const { return scale_; }
   const gfx::Rect& bounding_box() const { return bounding_box_; }
   int tap_count() const { return tap_count_; }
   int flags() const { return flags_; }
+  const ui::LatencyInfo& latency_info() const { return latency_info_; }
 
   void WaitUntilReceivedGesture(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
     events_.push_back(gesture->type());
     bounding_box_ = gesture->details().bounding_box();
     flags_ = gesture->flags();
+    latency_info_ = *gesture->latency();
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
         tap_location_ = gesture->location();
         tap_count_ = gesture->details().tap_count();
         tap_ = true;
         break;
       case ui::ET_GESTURE_TAP_DOWN:
         tap_down_ = true;
         break;
       case ui::ET_GESTURE_TAP_CANCEL:
@@ skipping 104 matching lines @@
   float scroll_velocity_x_;
   float scroll_velocity_y_;
   float velocity_x_;
   float velocity_y_;
   float scroll_x_hint_;
   float scroll_y_hint_;
   float scale_;
   gfx::Rect bounding_box_;
   int tap_count_;
   int flags_;
+  ui::LatencyInfo latency_info_;
 
   ui::EventType wait_until_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
       : window_(NULL),
@@ skipping 3933 matching lines @@
   int default_flags = delegate->flags();
 
   ui::TouchEvent move1(
       ui::ET_TOUCH_MOVED, gfx::Point(397, 149), kTouchId, tes.LeapForward(50));
   move1.set_flags(992);
 
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_NE(default_flags, delegate->flags());
 }
 
+// Test that latency info is passed through to the gesture event.
+TEST_P(GestureRecognizerTest, LatencyPassedFromTouchEvent) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  TimedEvents tes;
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 6;
+
+  const base::TimeTicks time_original = base::TimeTicks::FromInternalValue(100);
+  const base::TimeTicks time_ui = base::TimeTicks::FromInternalValue(200);
+  const base::TimeTicks time_acked = base::TimeTicks::FromInternalValue(300);
+
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, root_window()));
+
+  delegate->Reset();
+
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                        kTouchId, tes.Now());
+
+  // Ensure the only components around are the ones we add.
+  press1.latency()->Clear();
+
+  press1.latency()->AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, 0, time_original, 1);
+
+  press1.latency()->AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0, time_ui, 1);
+
+  press1.latency()->AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 0, 0, time_acked, 1);
+
+  DispatchEventUsingWindowDispatcher(&press1);
+  EXPECT_TRUE(delegate->tap_down());
+
+  ui::LatencyInfo::LatencyComponent component;
+
+  ASSERT_TRUE(delegate->latency_info().FindLatency(
+      ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, &component));
+  EXPECT_EQ(time_original, component.event_time);
+
+  ASSERT_TRUE(delegate->latency_info().FindLatency(
+      ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, &component));
+  EXPECT_EQ(time_ui, component.event_time);
+
+  ASSERT_TRUE(delegate->latency_info().FindLatency(
+      ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 0, &component));
+  EXPECT_EQ(time_acked, component.event_time);
+}
+
 INSTANTIATE_TEST_CASE_P(GestureRecognizer,
                         GestureRecognizerTest,
                         ::testing::Bool());
 
 }  // namespace test
 }  // namespace aura