revert "SourceEventType added to LatencyInfo."

content/browser/site_per_process_browsertest.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/site_per_process_browsertest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 46 matching lines @@
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInsecureRequestPolicy.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
-#include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point.h"
 
 #if defined(USE_AURA)
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "ui/base/test/scoped_preferred_scroller_style_mac.h"
 #endif
 
@@ skipping 171 matching lines @@
 
   // Target input event to child frame.
   blink::WebMouseEvent child_event;
   child_event.type = blink::WebInputEvent::MouseDown;
   child_event.button = blink::WebPointerProperties::Button::Left;
   child_event.x = 75;
   child_event.y = 75;
   child_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &child_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &child_event);
 
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
   EXPECT_EQ(23, child_frame_monitor.event().x);
   EXPECT_EQ(23, child_frame_monitor.event().y);
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
 
   child_frame_monitor.ResetEventReceived();
   main_frame_monitor.ResetEventReceived();
 
   // Target input event to main frame.
   blink::WebMouseEvent main_event;
   main_event.type = blink::WebInputEvent::MouseDown;
   main_event.button = blink::WebPointerProperties::Button::Left;
   main_event.x = 1;
   main_event.y = 1;
   main_event.clickCount = 1;
   // Ladies and gentlemen, THIS is the main_event!
-  router->RouteMouseEvent(root_view, &main_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &main_event);
 
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_EQ(1, main_frame_monitor.event().x);
   EXPECT_EQ(1, main_frame_monitor.event().y);
 }
 
 class RedirectNotificationObserver : public NotificationObserver {
  public:
   // Register to listen for notifications of the given type from either a
@@ skipping 931 matching lines @@
 
   // Target input event to nested frame.
   blink::WebMouseEvent nested_event;
   nested_event.type = blink::WebInputEvent::MouseDown;
   nested_event.button = blink::WebPointerProperties::Button::Left;
   nested_event.x = 125;
   nested_event.y = 125;
   nested_event.clickCount = 1;
   nested_frame_monitor.ResetEventReceived();
   main_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &nested_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &nested_event);
 
   EXPECT_TRUE(nested_frame_monitor.EventWasReceived());
   EXPECT_EQ(21, nested_frame_monitor.event().x);
   EXPECT_EQ(21, nested_frame_monitor.event().y);
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
 }
 
 // This test tests that browser process hittesting ignores frames with
 // pointer-events: none.
 #if defined(OS_ANDROID)
@@ skipping 44 matching lines @@
 
   // Target input event to child frame.
   blink::WebMouseEvent child_event;
   child_event.type = blink::WebInputEvent::MouseDown;
   child_event.button = blink::WebPointerProperties::Button::Left;
   child_event.x = 75;
   child_event.y = 75;
   child_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &child_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &child_event);
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_EQ(75, main_frame_monitor.event().x);
   EXPECT_EQ(75, main_frame_monitor.event().y);
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 }
 
 // This test verifies that MouseEnter and MouseLeave events fire correctly
 // when the mouse cursor moves between processes.
 #if defined(OS_ANDROID)
@@ skipping 64 matching lines @@
   gfx::Point point_in_b_frame(313, 147);
   gfx::Point point_in_d_frame(471, 207);
 
   blink::WebMouseEvent mouse_event;
   mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.x = point_in_a_frame.x();
   mouse_event.y = point_in_a_frame.y();
 
   // Send an initial MouseMove to the root view, which shouldn't affect the
   // other renderers.
-  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event,
-                                                         ui::LatencyInfo());
+  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event);
   EXPECT_TRUE(a_frame_monitor.EventWasReceived());
   a_frame_monitor.ResetEventReceived();
   EXPECT_FALSE(b_frame_monitor.EventWasReceived());
   EXPECT_FALSE(c_frame_monitor.EventWasReceived());
   EXPECT_FALSE(d_frame_monitor.EventWasReceived());
 
   // Next send a MouseMove to B frame, which shouldn't affect C or D but
   // A should receive a MouseMove event.
   mouse_event.x = point_in_b_frame.x();
   mouse_event.y = point_in_b_frame.y();
-  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event,
-                                                         ui::LatencyInfo());
+  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event);
   EXPECT_TRUE(a_frame_monitor.EventWasReceived());
   EXPECT_EQ(a_frame_monitor.event().type, blink::WebInputEvent::MouseMove);
   a_frame_monitor.ResetEventReceived();
   EXPECT_TRUE(b_frame_monitor.EventWasReceived());
   b_frame_monitor.ResetEventReceived();
   EXPECT_FALSE(c_frame_monitor.EventWasReceived());
   EXPECT_FALSE(d_frame_monitor.EventWasReceived());
 
   // Next send a MouseMove to D frame, which should have side effects in every
   // other RenderWidgetHostView.
   mouse_event.x = point_in_d_frame.x();
   mouse_event.y = point_in_d_frame.y();
-  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event,
-                                                         ui::LatencyInfo());
+  web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event);
   EXPECT_TRUE(a_frame_monitor.EventWasReceived());
   EXPECT_EQ(a_frame_monitor.event().type, blink::WebInputEvent::MouseMove);
   EXPECT_TRUE(b_frame_monitor.EventWasReceived());
   EXPECT_EQ(b_frame_monitor.event().type, blink::WebInputEvent::MouseLeave);
   EXPECT_TRUE(c_frame_monitor.EventWasReceived());
   EXPECT_EQ(c_frame_monitor.event().type, blink::WebInputEvent::MouseMove);
   EXPECT_TRUE(d_frame_monitor.EventWasReceived());
 }
 
 // Verify that mouse capture works on a RenderWidgetHostView level, so that
@@ skipping 42 matching lines @@
 
   // Target MouseDown to child frame.
   blink::WebMouseEvent mouse_event;
   mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.button = blink::WebPointerProperties::Button::Left;
   mouse_event.x = 75;
   mouse_event.y = 75;
   mouse_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // Target MouseMove to main frame. This should still be routed to the
   // child frame because it is now capturing mouse input.
   mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.modifiers = blink::WebInputEvent::LeftButtonDown;
   mouse_event.x = 1;
   mouse_event.y = 1;
   // Note that this event is sent twice, with the monitors cleared after
   // the first time, because the first MouseMove to the child frame
   // causes a MouseMove to be sent to the main frame also, which we
   // need to ignore.
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   mouse_event.x = 1;
   mouse_event.y = 2;
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // A MouseUp to the child frame should cancel the mouse capture.
   mouse_event.type = blink::WebInputEvent::MouseUp;
   mouse_event.modifiers = 0;
   mouse_event.x = 75;
   mouse_event.y = 75;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // Subsequent MouseMove events targeted to the main frame should be routed
   // to that frame.
   mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.x = 1;
   mouse_event.y = 3;
   // Sending the MouseMove twice for the same reason as above.
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   mouse_event.x = 1;
   mouse_event.y = 4;
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 
   // Target MouseDown to the main frame to cause it to capture input.
   mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.x = 1;
   mouse_event.y = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 
   // Sending a MouseMove to the child frame should still result in the main
   // frame receiving the event.
   mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.modifiers = blink::WebInputEvent::LeftButtonDown;
   mouse_event.x = 75;
   mouse_event.y = 75;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
-  router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &mouse_event);
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 }
 
 // Tests OOPIF rendering by checking that the RWH of the iframe generates
 // OnSwapCompositorFrame message.
 #if defined(OS_ANDROID)
 // http://crbug.com/471850
 #define MAYBE_CompositorFrameSwapped DISABLED_CompositorFrameSwapped
@@ skipping 3547 matching lines @@
   // Send a MouseMove to the subframe. The frame contains text, and moving the
   // mouse over it should cause the renderer to send a mouse cursor update.
   blink::WebMouseEvent mouse_event;
   mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.x = 60;
   mouse_event.y = 60;
   RenderWidgetHost* rwh_child =
       root->child_at(0)->current_frame_host()->GetRenderWidgetHost();
   RenderWidgetHostViewBase* root_view = static_cast<RenderWidgetHostViewBase*>(
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
-  web_contents()->GetInputEventRouter()->RouteMouseEvent(
-      root_view, &mouse_event, ui::LatencyInfo());
+  web_contents()->GetInputEventRouter()->RouteMouseEvent(root_view,
+                                                         &mouse_event);
 
   // CursorMessageFilter::Wait() implicitly tests whether we receive a
   // ViewHostMsg_SetCursor message from the renderer process, because it does
   // does not return otherwise.
   filter->Wait();
   EXPECT_EQ(filter->last_set_cursor_routing_id(), rwh_child->GetRoutingID());
 }
 #endif
 
 // Tests that we are using the correct RenderFrameProxy when navigating an
@@ skipping 504 matching lines @@
 
   gfx::Point point(75, 75);
 
   // Target right-click event to child frame.
   blink::WebMouseEvent click_event;
   click_event.type = blink::WebInputEvent::MouseDown;
   click_event.button = blink::WebPointerProperties::Button::Right;
   click_event.x = point.x();
   click_event.y = point.y();
   click_event.clickCount = 1;
-  router->RouteMouseEvent(root_view, &click_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &click_event);
 
   // We also need a MouseUp event, needed by Windows.
   click_event.type = blink::WebInputEvent::MouseUp;
   click_event.x = point.x();
   click_event.y = point.y();
-  router->RouteMouseEvent(root_view, &click_event, ui::LatencyInfo());
+  router->RouteMouseEvent(root_view, &click_event);
 
   context_menu_delegate.Wait();
 
   ContextMenuParams params = context_menu_delegate.getParams();
 
   EXPECT_EQ(point.x(), params.x);
   EXPECT_EQ(point.y(), params.y);
 }
 
 // Test that a mouse right-click to an out-of-process iframe causes a context
@@ skipping 2572 matching lines @@
       " Site A ------------ proxies for B C\n"
       "   +--Site B ------- proxies for A C\n"
       "        +--Site C -- proxies for A B\n"
       "Where A = http://a.com/\n"
       "      B = http://b.com/\n"
       "      C = http://c.com/",
       DepictFrameTree(root));
 }
 
 }  // namespace content