Synthesize proper keyIdentifier for devtools protocol key events.

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

 // Copyright 2013 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/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ skipping 11 matching lines @@
 namespace {
 
 const char kIdParam[] = "id";
 const char kMethodParam[] = "method";
 const char kParamsParam[] = "params";
 
 }
 
 class DevToolsProtocolTest : public ContentBrowserTest,
                              public DevToolsAgentHostClient {
+ public:
+  DevToolsProtocolTest() : has_dispatched_command(false) {}
+
  protected:
   void SendCommand(const std::string& method,
                    scoped_ptr<base::DictionaryValue> params) {
     base::DictionaryValue command;
+    has_dispatched_command = false;
     command.SetInteger(kIdParam, 1);
     command.SetString(kMethodParam, method);
     if (params)
       command.Set(kParamsParam, params.release());
 
     std::string json_command;
     base::JSONWriter::Write(command, &json_command);
     agent_host_->DispatchProtocolMessage(json_command);
-    base::MessageLoop::current()->Run();
+    // Some messages are dispatched synchronously.
+    // Only run loop if we are not finished yet.
+    if (!has_dispatched_command)
+      base::MessageLoop::current()->Run();
   }
 
   bool HasValue(const std::string& path) {
     base::Value* value = 0;
     return result_->Get(path, &value);
   }
 
   bool HasListItem(const std::string& path_to_list,
                    const std::string& name,
                    const std::string& value) {
@@ skipping 28 matching lines @@
   scoped_refptr<DevToolsAgentHost> agent_host_;
 
  private:
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
     scoped_ptr<base::DictionaryValue> root(
         static_cast<base::DictionaryValue*>(base::JSONReader::Read(message)));
     base::DictionaryValue* result;
     EXPECT_TRUE(root->GetDictionary("result", &result));
     result_.reset(result->DeepCopy());
-    base::MessageLoop::current()->QuitNow();
+    if (base::MessageLoop::current()->is_running())

[dgozman, 2015/05/25 16:02:10]

I probably don't understand something, but how current runloop may be not
running?

[mharanczyk, 2015/05/26 07:45:04]

Those tests are executed from main thread startup from
ShellBrowserMainParts::PreMainMessageLoopRun where message loop context is
initialized but is not run unless test startup
(ContentBrowserTest::RunTestOnMainThreadLoop calls
base::MessageLoopForUI::current()->RunUntilIdle() which starts and quits run
loop when startup tasks are done) or test itself decides to run it. In case of
DevToolsProtocolTest::SendCommand we start run loop only if message was not
handled synchronously, so for synchronous callback to
DevToolsProtocolTest::DispatchProtocolMessage run loop is not running and
calling QuitNow causes assertion.

+      base::MessageLoop::current()->QuitNow();
+    has_dispatched_command = true;
   }
 
   void AgentHostClosed(DevToolsAgentHost* agent_host, bool replaced) override {
     EXPECT_TRUE(false);
   }
+
+  bool has_dispatched_command;
 };
 
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, KeyEventsSynthesizeKeyIdentifier) {
+  GURL test_url = GetTestUrl("devtools", "synthetic_keyevent_test.html");
+  NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
+
+  // Send enter (keycode 13).
+  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  params->SetString("type", "rawKeyDown");
+  params->SetInteger("modifiers", 0);
+  params->SetInteger("windowsVirtualKeyCode", 13);
+  params->SetInteger("nativeVirtualKeyCode", 13);
+  SendCommand("Input.dispatchKeyEvent", params.Pass());
+
+  params.reset(new base::DictionaryValue());
+  params->SetString("type", "keyUp");
+  params->SetInteger("modifiers", 0);
+  params->SetInteger("windowsVirtualKeyCode", 13);
+  params->SetInteger("nativeVirtualKeyCode", 13);
+  SendCommand("Input.dispatchKeyEvent", params.Pass());
+
+  std::string keyIdentifier;
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      shell()->web_contents(),
+      "domAutomationController.send("
+          "document.getElementById('keyDownOutput').value)",
+      &keyIdentifier));
+  EXPECT_EQ("Enter", keyIdentifier);
+
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      shell()->web_contents(),
+      "domAutomationController.send("
+          "document.getElementById('keyUpOutput').value)",
+      &keyIdentifier));
+  EXPECT_EQ("Enter", keyIdentifier);
+
+  // Send escape (keycode 27).
+  params.reset(new base::DictionaryValue());
+  params->SetString("type", "rawKeyDown");
+  params->SetInteger("modifiers", 0);
+  params->SetInteger("windowsVirtualKeyCode", 27);
+  params->SetInteger("nativeVirtualKeyCode", 27);
+  SendCommand("Input.dispatchKeyEvent", params.Pass());
+
+  params.reset(new base::DictionaryValue());
+  params->SetString("type", "keyUp");
+  params->SetInteger("modifiers", 0);
+  params->SetInteger("windowsVirtualKeyCode", 27);
+  params->SetInteger("nativeVirtualKeyCode", 27);
+  SendCommand("Input.dispatchKeyEvent", params.Pass());
+
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      shell()->web_contents(),
+      "domAutomationController.send("
+          "document.getElementById('keyDownOutput').value)",
+      &keyIdentifier));
+  EXPECT_EQ("U+001B", keyIdentifier);
+
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      shell()->web_contents(),
+      "domAutomationController.send("
+          "document.getElementById('keyUpOutput').value)",
+      &keyIdentifier));
+  EXPECT_EQ("U+001B", keyIdentifier);
+}
+
 class CaptureScreenshotTest : public DevToolsProtocolTest {
  private:
 #if !defined(OS_ANDROID)
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnablePixelOutputInTests);
   }
 #endif
 };
 
 // Does not link on Android
@@ skipping 144 matching lines @@
   // new value of |document.body.scrollTop| will depend on the screen dimensions
   // of the device that we're testing on, but in any case it should be greater
   // than 0.
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_GT(scroll_top, 0);
 }
 
 }  // namespace content