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())
+      base::MessageLoop::current()->QuitNow();
+    has_dispatched_command = true;
   }
 
   void AgentHostClosed(DevToolsAgentHost* agent_host, bool replaced) override {
     EXPECT_TRUE(false);
   }
+
+  bool has_dispatched_command;
 };
 
+class SyntheticKeyEventTest : public DevToolsProtocolTest {
+ protected:
+  void SendKeyEvent(const std::string& type,
+                    int modifier,
+                    int windowsKeyCode,
+                    int nativeKeyCode) {
+    scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+    params->SetString("type", type);
+    params->SetInteger("modifiers", modifier);
+    params->SetInteger("windowsVirtualKeyCode", windowsKeyCode);
+    params->SetInteger("nativeVirtualKeyCode", nativeKeyCode);
+    SendCommand("Input.dispatchKeyEvent", params.Pass());
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(SyntheticKeyEventTest, KeyEventSynthesizeKeyIdentifier) {
+  NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
+  ASSERT_TRUE(content::ExecuteScript(
+      shell()->web_contents()->GetRenderViewHost(),
+      "function handleKeyEvent(event) {"
+        "domAutomationController.setAutomationId(0);"
+        "domAutomationController.send(event.keyIdentifier);"
+      "}"
+      "document.body.addEventListener('keydown', handleKeyEvent);"
+      "document.body.addEventListener('keyup', handleKeyEvent);"));
+
+  DOMMessageQueue dom_message_queue;
+
+  // Send enter (keycode 13).
+  SendKeyEvent("rawKeyDown", 0, 13, 13);
+  SendKeyEvent("keyUp", 0, 13, 13);
+
+  std::string key_identifier;
+  ASSERT_TRUE(dom_message_queue.WaitForMessage(&key_identifier));
+  EXPECT_EQ("\"Enter\"", key_identifier);
+  ASSERT_TRUE(dom_message_queue.WaitForMessage(&key_identifier));
+  EXPECT_EQ("\"Enter\"", key_identifier);
+
+  // Send escape (keycode 27).
+  SendKeyEvent("rawKeyDown", 0, 27, 27);
+  SendKeyEvent("keyUp", 0, 27, 27);
+
+  ASSERT_TRUE(dom_message_queue.WaitForMessage(&key_identifier));
+  EXPECT_EQ("\"U+001B\"", key_identifier);
+  ASSERT_TRUE(dom_message_queue.WaitForMessage(&key_identifier));
+  EXPECT_EQ("\"U+001B\"", key_identifier);
+}
+
 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