DevTools: add input event instrumentation test

chrome/browser/devtools/devtools_sanity_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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 31 matching lines @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/app_modal/javascript_app_modal_dialog.h"
 #include "components/app_modal/native_app_modal_dialog.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/value_builder.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gl/gl_switches.h"
 
 using app_modal::AppModalDialog;
 using app_modal::JavaScriptAppModalDialog;
 using app_modal::NativeAppModalDialog;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::RenderViewHost;
 using content::WebContents;
 using content::WorkerService;
 using content::WorkerServiceObserver;
 using extensions::Extension;
 
 namespace {
 
 const char kDebuggerTestPage[] = "files/devtools/debugger_test_page.html";
 const char kPauseWhenLoadingDevTools[] =
     "files/devtools/pause_when_loading_devtools.html";
 const char kPauseWhenScriptIsRunning[] =
     "files/devtools/pause_when_script_is_running.html";
 const char kPageWithContentScript[] =
     "files/devtools/page_with_content_script.html";
 const char kNavigateBackTestPage[] =
     "files/devtools/navigate_back.html";
 const char kWindowOpenTestPage[] = "files/devtools/window_open.html";
+const char kLatencyInfoTestPage[] = "files/devtools/latency_info.html";
 const char kChunkedTestPage[] = "chunked";
 const char kSlowTestPage[] =
     "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2";
 const char kSharedWorkerTestPage[] =
     "files/workers/workers_ui_shared_worker.html";
 const char kSharedWorkerTestWorker[] =
     "files/workers/workers_ui_shared_worker.js";
 const char kReloadSharedWorkerTestPage[] =
     "files/workers/debug_shared_worker_initialization.html";
 const char kReloadSharedWorkerTestWorker[] =
     "files/workers/debug_shared_worker_initialization.js";
 
 template <typename... T>
+void DispatchOnTestSuiteSkipCheck(DevToolsWindow* window,
+                                  const char* method,
+                                  T... args) {
+  RenderViewHost* rvh = DevToolsWindowTesting::Get(window)
+                            ->main_web_contents()
+                            ->GetRenderViewHost();
+  std::string result;
+  const char* args_array[] = {method, args...};
+  std::ostringstream script;
+  script << "uiTests.dispatchOnTestSuite([";
+  for (size_t i = 0; i < arraysize(args_array); ++i)
+    script << (i ? "," : "") << '\"' << args_array[i] << '\"';
+  script << "])";
+  ASSERT_TRUE(
+      content::ExecuteScriptAndExtractString(rvh, script.str(), &result));
+  EXPECT_EQ("[OK]", result);
+}
+
+template <typename... T>
 void DispatchOnTestSuite(DevToolsWindow* window,
                          const char* method,
                          T... args) {
   std::string result;
   RenderViewHost* rvh = DevToolsWindowTesting::Get(window)
                             ->main_web_contents()
                             ->GetRenderViewHost();
   // At first check that JavaScript part of the front-end is loaded by
   // checking that global variable uiTests exists(it's created after all js
   // files have been loaded) and has runTest method.
   ASSERT_TRUE(
       content::ExecuteScriptAndExtractString(
           rvh,
           "window.domAutomationController.send("
           "    '' + (window.uiTests && (typeof uiTests.dispatchOnTestSuite)));",
           &result));
   ASSERT_EQ("function", result) << "DevTools front-end is broken.";
-
-  const char* args_array[] = {method, args...};
-  std::ostringstream script;
-  script << "uiTests.dispatchOnTestSuite([";
-  for (size_t i = 0; i < arraysize(args_array); ++i)
-    script << (i ? "," : "") << '\"' << args_array[i] << '\"';
-  script << "])";
-  ASSERT_TRUE(
-      content::ExecuteScriptAndExtractString(rvh, script.str(), &result));
-  EXPECT_EQ("[OK]", result);
+  DispatchOnTestSuiteSkipCheck(window, method, args...);
 }
 
 void RunTestFunction(DevToolsWindow* window, const char* test_name) {
   DispatchOnTestSuite(window, test_name);
 }
 
 void SwitchToPanel(DevToolsWindow* window, const char* panel) {
   DispatchOnTestSuite(window, "switchToPanel", panel);
 }
 
@@ skipping 19 matching lines @@
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
  protected:
   void RunTest(const std::string& test_name, const std::string& test_page) {
     OpenDevToolsWindow(test_page, false);
     RunTestFunction(window_, test_name.c_str());
     CloseDevToolsWindow();
   }
 
+  template <typename... T>
+  void RunTestMethod(const char* method, T... args) {
+    DispatchOnTestSuiteSkipCheck(window_, method, args...);
+  }
+
+  template <typename... T>
+  void DispatchAndWait(const char* method, T... args) {
+    DispatchOnTestSuiteSkipCheck(window_, "waitForAsync", method, args...);
+  }
+
+  template <typename... T>
+  void DispatchInPageAndWait(const char* method, T... args) {
+    DispatchAndWait("invokePageFunctionAsync", method, args...);
+  }
+
   void LoadTestPage(const std::string& test_page) {
     GURL url = spawned_test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
   }
 
   void OpenDevToolsWindow(const std::string& test_page, bool is_docked) {
     ASSERT_TRUE(spawned_test_server()->Start());
     LoadTestPage(test_page);
 
     window_ = DevToolsWindowTesting::OpenDevToolsWindowSync(GetInspectedTab(),
@@ skipping 957 matching lines @@
 };
 
 // This test enables switches::kUseGpuInTests which causes false positives
 // with MemorySanitizer.
 #if defined(MEMORY_SANITIZER) || defined(ADDRESS_SANITIZER) || \
     (defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 #define MAYBE_TestScreenshotRecording DISABLED_TestScreenshotRecording
 #else
 #define MAYBE_TestScreenshotRecording TestScreenshotRecording
 #endif
-// Tests raw headers text.
 IN_PROC_BROWSER_TEST_F(DevToolsPixelOutputTests,
                        MAYBE_TestScreenshotRecording) {
   RunTest("testScreenshotRecording", std::string());
 }
+
+// This test enables switches::kUseGpuInTests which causes false positives
+// with MemorySanitizer.
+#if defined(MEMORY_SANITIZER) || defined(ADDRESS_SANITIZER)
+#define MAYBE_TestLatencyInfoInstrumentation \
+  DISABLED_TestLatencyInfoInstrumentation
+#else
+#define MAYBE_TestLatencyInfoInstrumentation TestLatencyInfoInstrumentation
+#endif
+IN_PROC_BROWSER_TEST_F(DevToolsPixelOutputTests,
+                       MAYBE_TestLatencyInfoInstrumentation) {
+  WebContents* web_contents = GetInspectedTab();
+  OpenDevToolsWindow(kLatencyInfoTestPage, false);
+  RunTestMethod("enableExperiment", "timelineLatencyInfo");
+  DispatchAndWait("startTimeline");
+
+  for (int i = 0; i < 3; ++i) {
+    SimulateMouseEvent(web_contents, blink::WebInputEvent::MouseMove,
+                       gfx::Point(30, 60));
+    DispatchInPageAndWait("waitForEvent", "mousemove");
+  }
+
+  SimulateMouseClickAt(web_contents, 0, blink::WebPointerProperties::ButtonLeft,
+                       gfx::Point(30, 60));
+  DispatchInPageAndWait("waitForEvent", "click");
+
+  SimulateMouseWheelEvent(web_contents, gfx::Point(300, 100),
+                          gfx::Vector2d(0, 120));
+  DispatchInPageAndWait("waitForEvent", "wheel");
+
+  SimulateTapAt(web_contents, gfx::Point(30, 60));
+  DispatchInPageAndWait("waitForEvent", "gesturetap");
+
+  DispatchAndWait("stopTimeline");
+  RunTestMethod("checkInputEventsPresent", "MouseMove", "MouseDown",
+                "MouseWheel", "GestureTap");
+
+  CloseDevToolsWindow();
+}