SourceEventType added to LatencyInfo

content/browser/renderer_host/render_widget_host_view_aura_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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 415 matching lines @@
  private:
   aura::Window* owner_;
   DISALLOW_COPY_AND_ASSIGN(FullscreenLayoutManager);
 };
 
 class MockWindowObserver : public aura::WindowObserver {
  public:
   MOCK_METHOD2(OnDelegatedFrameDamage, void(aura::Window*, const gfx::Rect&));
 };
 
+class MockRenderWidgetHostImpl : public RenderWidgetHostImpl {
+ public:
+  MockRenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
+                           RenderProcessHost* process,
+                           int32_t routing_id)
+      : RenderWidgetHostImpl(delegate, process, routing_id, false) {
+    set_renderer_initialized(true);
+    lastWheelOrTouchEventLatencyInfo = ui::LatencyInfo();
+  }
+
+  // Extracts |latency_info| for wheel event, and stores it in
+  // |lastWheelOrTouchEventLatencyInfo|.
+  void ForwardWheelEventWithLatencyInfo(
+      const blink::WebMouseWheelEvent& wheel_event,
+      const ui::LatencyInfo& ui_latency) override {
+    RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo(wheel_event,
+                                                           ui_latency);
+    lastWheelOrTouchEventLatencyInfo = ui::LatencyInfo(ui_latency);
+  }
+
+  // Extracts |latency_info| for touch event, and stores it in
+  // |lastWheelOrTouchEventLatencyInfo|.
+  void ForwardTouchEventWithLatencyInfo(
+      const blink::WebTouchEvent& touch_event,
+      const ui::LatencyInfo& ui_latency) override {
+    RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfo(touch_event,
+                                                           ui_latency);
+    lastWheelOrTouchEventLatencyInfo = ui::LatencyInfo(ui_latency);
+  }
+
+  ui::LatencyInfo lastWheelOrTouchEventLatencyInfo;
+};
+
 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) {
   base::PickleIterator iter(message);
   const char* data;
   int data_length;
   if (!iter.ReadData(&data, &data_length))
     return nullptr;
   return reinterpret_cast<const WebInputEvent*>(data);
 }
 
 }  // namespace
@@ skipping 27 matching lines @@
     delegates_.back()->set_widget_host(parent_host_);
     parent_view_ = new RenderWidgetHostViewAura(parent_host_,
                                                 is_guest_view_hack_);
     parent_view_->InitAsChild(nullptr);
     aura::client::ParentWindowWithContext(parent_view_->GetNativeView(),
                                           aura_test_helper_->root_window(),
                                           gfx::Rect());
 
     routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
-    widget_host_ = new RenderWidgetHostImpl(delegates_.back().get(),
-                                            process_host_, routing_id, false);
+    widget_host_ = new MockRenderWidgetHostImpl(delegates_.back().get(),
+                                                process_host_, routing_id);
     delegates_.back()->set_widget_host(widget_host_);
     widget_host_->Init();
     view_ = new FakeRenderWidgetHostViewAura(widget_host_, is_guest_view_hack_);
   }
 
   void TearDownEnvironment() {
     sink_ = nullptr;
     process_host_ = nullptr;
     if (view_) {
       // For guest-views, |view_| is not the view used by |widget_host_|.
@@ skipping 139 matching lines @@
   std::vector<std::unique_ptr<MockRenderWidgetHostDelegate>> delegates_;
   MockRenderProcessHost* process_host_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
   RenderWidgetHostImpl* parent_host_;
   RenderWidgetHostViewAura* parent_view_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
-  RenderWidgetHostImpl* widget_host_;
+  MockRenderWidgetHostImpl* widget_host_;
   FakeRenderWidgetHostViewAura* view_;
 
   IPC::TestSink* sink_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraTest);
 };
 
 // Helper class to instantiate RenderWidgetHostViewGuest which is backed
 // by an aura platform view.
@@ skipping 1851 matching lines @@
   // scale on it.
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(2.f, frame_size, gfx::Rect(frame_size)));
 
   // When we get a new frame with the same frame size in physical pixels, but
   // a different scale, we should generate a surface, as the final result will
   // need to be scaled differently to the screen.
   EXPECT_NE(surface_id, view_->surface_id());
 }
 
+TEST_F(RenderWidgetHostViewAuraTest, SourceEventTypeExistsInLatencyInfo) {
+  // WHEEL source exists.
+  ui::ScrollEvent scroll(ui::ET_SCROLL, gfx::Point(2, 2), ui::EventTimeForNow(),
+                         0, 0, 0, 0, 0, 2);
+  view_->OnScrollEvent(&scroll);
+  EXPECT_EQ(widget_host_->lastWheelOrTouchEventLatencyInfo.source_event_type(),
+            ui::SourceEventType::WHEEL);
+
+  // TOUCH source exists.
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0,
+                       ui::EventTimeForNow());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
+                      ui::EventTimeForNow());
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0,
+                         ui::EventTimeForNow());
+  view_->OnTouchEvent(&press);
+  view_->OnTouchEvent(&move);
+  EXPECT_EQ(widget_host_->lastWheelOrTouchEventLatencyInfo.source_event_type(),
+            ui::SourceEventType::TOUCH);
+  view_->OnTouchEvent(&release);
+}
+
 class RenderWidgetHostViewAuraCopyRequestTest
     : public RenderWidgetHostViewAuraShutdownTest {
  public:
   RenderWidgetHostViewAuraCopyRequestTest()
       : callback_count_(0),
         result_(false),
         frame_subscriber_(nullptr),
         tick_clock_(nullptr),
         view_rect_(100, 100) {}
 
@@ skipping 2062 matching lines @@
 
     // Retrieve the selected text from clipboard and verify it is as expected.
     base::string16 result_text;
     clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
     EXPECT_EQ(expected_text, result_text);
   }
 }
 #endif
 
 }  // namespace content