Allow webdriver users to choose between sending the key events when...

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2011 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 "chrome/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 2122 matching lines @@
   handler_map["CloseTab"] =
       &TestingAutomationProvider::CloseTabJSON;
   handler_map["WebkitMouseMove"] =
       &TestingAutomationProvider::WebkitMouseMove;
   handler_map["WebkitMouseClick"] =
       &TestingAutomationProvider::WebkitMouseClick;
   handler_map["WebkitMouseDrag"] =
       &TestingAutomationProvider::WebkitMouseDrag;
   handler_map["SendWebkitKeyEvent"] =
       &TestingAutomationProvider::SendWebkitKeyEvent;
+  handler_map["SendOSLevelKeyEvent"] =
+      &TestingAutomationProvider::SendOSLevelKeyEvent;
   handler_map["ActivateTab"] =
       &TestingAutomationProvider::ActivateTabJSON;
 #if defined(OS_CHROMEOS)
   handler_map["LoginAsGuest"] = &TestingAutomationProvider::LoginAsGuest;
   handler_map["Login"] = &TestingAutomationProvider::Login;
   handler_map["Logout"] = &TestingAutomationProvider::Logout;
   handler_map["ScreenLock"] = &TestingAutomationProvider::ScreenLock;
   handler_map["ScreenUnlock"] = &TestingAutomationProvider::ScreenUnlock;
 
   handler_map["GetNetworkInfo"] = &TestingAutomationProvider::GetNetworkInfo;
@@ skipping 2427 matching lines @@
   if (!base::OpenProcessHandle(static_cast<base::ProcessId>(pid), &process)) {
     AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
         "Failed to open process handle for pid %d", pid));
     return;
   }
   new RendererProcessClosedObserver(this, reply_message);
   base::KillProcess(process, 0, false);
   base::CloseProcessHandle(process);
 }
 
+bool TestingAutomationProvider::BuildWebKeyEventFromArgs(
+    DictionaryValue* args,
+    IPC::Message* reply_message,
+    NativeWebKeyboardEvent* event) {
+
+  int type, modifiers;
+  bool is_system_key;
+  string16 unmodified_text, text;
+  std::string key_identifier;
+    if (!args->GetInteger("type", &type)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'type' missing or invalid.");
+    return false;
+  }
+  if (!args->GetBoolean("isSystemKey", &is_system_key)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'isSystemKey' missing or invalid.");
+    return false;
+  }
+  if (!args->GetString("unmodifiedText", &unmodified_text)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'unmodifiedText' missing or invalid.");
+    return false;
+  }
+  if (!args->GetString("text", &text)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'text' missing or invalid.");
+    return false;
+  }
+  if (!args->GetInteger("nativeKeyCode", &event->nativeKeyCode)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'nativeKeyCode' missing or invalid.");
+    return false;
+  }
+  if (!args->GetInteger("windowsKeyCode", &event->windowsKeyCode)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'windowsKeyCode' missing or invalid.");
+    return false;
+  }
+  if (!args->GetInteger("modifiers", &modifiers)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'modifiers' missing or invalid.");
+    return false;
+  }
+  if (args->GetString("keyIdentifier", &key_identifier)) {
+    base::strlcpy(event->keyIdentifier,
+                  key_identifier.c_str(),
+                  WebKit::WebKeyboardEvent::keyIdentifierLengthCap);
+  } else {
+    event->setKeyIdentifierFromWindowsKeyCode();
+  }
+
+  if (type == automation::kRawKeyDownType) {
+    event->type = WebKit::WebInputEvent::RawKeyDown;
+  } else if (type == automation::kKeyDownType) {
+    event->type = WebKit::WebInputEvent::KeyDown;
+  } else if (type == automation::kKeyUpType) {
+    event->type = WebKit::WebInputEvent::KeyUp;
+  } else if (type == automation::kCharType) {
+    event->type = WebKit::WebInputEvent::Char;
+  } else {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'type' refers to an unrecognized keyboard event type");
+    return false;
+  }
+
+  string16 unmodified_text_truncated = unmodified_text.substr(
+      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
+  memcpy(event->unmodifiedText,
+         unmodified_text_truncated.c_str(),
+         unmodified_text_truncated.length() + 1);
+  string16 text_truncated = text.substr(
+      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
+  memcpy(event->text, text_truncated.c_str(), text_truncated.length() + 1);
+
+  event->modifiers = 0;
+  if (modifiers & automation::kShiftKeyMask)
+    event->modifiers |= WebKit::WebInputEvent::ShiftKey;
+  if (modifiers & automation::kControlKeyMask)
+    event->modifiers |= WebKit::WebInputEvent::ControlKey;
+  if (modifiers & automation::kAltKeyMask)
+    event->modifiers |= WebKit::WebInputEvent::AltKey;
+  if (modifiers & automation::kMetaKeyMask)
+    event->modifiers |= WebKit::WebInputEvent::MetaKey;
+
+  event->isSystemKey = is_system_key;
+  event->timeStampSeconds = base::Time::Now().ToDoubleT();
+  event->skip_in_browser = true;
+  return true;
+}
+
 void TestingAutomationProvider::SendWebkitKeyEvent(
     DictionaryValue* args,
     IPC::Message* reply_message) {
+  NativeWebKeyboardEvent event;
+  // BuildWebKeyEventFromArgs handles telling what when wrong and sending
+  // the reply message, if it failed we just have to stop here.
+  if (!BuildWebKeyEventFromArgs(args, reply_message, &event))

[kkania, 2011/03/11 16:32:13]

I am not sure what the benefit of having this additional function is.

[timothe, 2011/03/21 18:02:05]

As the fact of building a key event form the args took most of the lines of this
method, I found it cleaner to refactor it into another one for this purpose
only, leaving this one hopefully more understandable.

+    return;
+
   TabContents* tab_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
+  LOG(INFO) << "reply_message:" << reply_message;
+  new InputEventAckNotificationObserver(this, reply_message, event.type);
+  tab_contents->render_view_host()->ForwardKeyboardEvent(event);
+}
 
-  int type, modifiers;
-  bool is_system_key;
-  string16 unmodified_text, text;
-  std::string key_identifier;
-  NativeWebKeyboardEvent event;
-  if (!args->GetInteger("type", &type)) {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'type' missing or invalid.");
-    return;
-  }
-  if (!args->GetBoolean("isSystemKey", &is_system_key)) {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'isSystemKey' missing or invalid.");
-    return;
-  }
-  if (!args->GetString("unmodifiedText", &unmodified_text)) {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'unmodifiedText' missing or invalid.");
-    return;
-  }
-  if (!args->GetString("text", &text)) {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'text' missing or invalid.");
-    return;
-  }
-  if (!args->GetInteger("nativeKeyCode", &event.nativeKeyCode)) {
-    AutomationJSONReply reply(this, reply_message);
+void TestingAutomationProvider::SendOSLevelKeyEvent(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  int modifiers, keycode;
+  AutomationJSONReply reply(this, reply_message);
+  if (!args->GetInteger("nativeKeyCode", &keycode)) {

[kkania, 2011/03/11 16:32:13]

i think the keycode you are passing in is actually a ui::KeyboardCode, which is
a windowsKeyCode, not a native one (except on win). I know the SendWebkitKey one
passes both in as the same, but that is not really correct.

[timothe, 2011/03/21 18:02:05]

Yes indeed it is a ui::KeyboardCode, I don't quite get the difference between a
"windowskeycode" and a "native one" though.
What do you suggest?

On 2011/03/11 16:32:13, kkania wrote:

     reply.SendError("'nativeKeyCode' missing or invalid.");
     return;
   }
-  if (!args->GetInteger("windowsKeyCode", &event.windowsKeyCode)) {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'windowsKeyCode' missing or invalid.");
-    return;
-  }
   if (!args->GetInteger("modifiers", &modifiers)) {
-    AutomationJSONReply reply(this, reply_message);
     reply.SendError("'modifiers' missing or invalid.");
     return;
   }
-  if (args->GetString("keyIdentifier", &key_identifier)) {
-    base::strlcpy(event.keyIdentifier,
-                  key_identifier.c_str(),
-                  WebKit::WebKeyboardEvent::keyIdentifierLengthCap);
-  } else {
-    event.setKeyIdentifierFromWindowsKeyCode();
-  }
 
-  if (type == automation::kRawKeyDownType) {
-    event.type = WebKit::WebInputEvent::RawKeyDown;
-  } else if (type == automation::kKeyDownType) {
-    event.type = WebKit::WebInputEvent::KeyDown;
-  } else if (type == automation::kKeyUpType) {
-    event.type = WebKit::WebInputEvent::KeyUp;
-  } else if (type == automation::kCharType) {
-    event.type = WebKit::WebInputEvent::Char;
-  } else {
-    AutomationJSONReply reply(this, reply_message);
-    reply.SendError("'type' refers to an unrecognized keyboard event type");
+  Browser* browser;
+  std::string error;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {

[kkania, 2011/03/11 16:32:13]

I think you should also get TabContents here and then
browser->SelectTabContentsAt(
      browser->GetIndexOfController(&tab_contents->controller()), true);

or if you prefer, you can just remove the tab_index input parameter and require
the user change the tab before

[timothe, 2011/03/21 18:02:05]

Done.

+    reply.SendError(error);
     return;
   }
-
-  string16 unmodified_text_truncated = unmodified_text.substr(
-      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
-  memcpy(event.unmodifiedText,
-         unmodified_text_truncated.c_str(),
-         unmodified_text_truncated.length() + 1);
-  string16 text_truncated = text.substr(
-      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
-  memcpy(event.text, text_truncated.c_str(), text_truncated.length() + 1);
-
-  event.modifiers = 0;
-  if (modifiers & automation::kShiftKeyMask)
-    event.modifiers |= WebKit::WebInputEvent::ShiftKey;
-  if (modifiers & automation::kControlKeyMask)
-    event.modifiers |= WebKit::WebInputEvent::ControlKey;
-  if (modifiers & automation::kAltKeyMask)
-    event.modifiers |= WebKit::WebInputEvent::AltKey;
-  if (modifiers & automation::kMetaKeyMask)
-    event.modifiers |= WebKit::WebInputEvent::MetaKey;
-
-  event.isSystemKey = is_system_key;
-  event.timeStampSeconds = base::Time::Now().ToDoubleT();
-  event.skip_in_browser = true;
-  new InputEventAckNotificationObserver(this, reply_message, event.type);
-  tab_contents->render_view_host()->ForwardKeyboardEvent(event);
+  BrowserWindow* browser_window = browser->window();
+  if (!browser_window) {
+    reply.SendError("Could not get the browser window");
+    return;
+  }
+  gfx::NativeWindow window = browser_window->GetNativeHandle();
+  if (!window) {
+    reply.SendError("Could not get the browser window handle");
+    return;
+  }
+  bool control = !!(modifiers & automation::kControlKeyMask);
+  bool shift = !!(modifiers & automation::kShiftKeyMask);
+  bool alt = !!(modifiers & automation::kAltKeyMask);
+  bool meta = !!(modifiers & automation::kMetaKeyMask);
+  if (!ui_controls::SendKeyPress(
+          window, static_cast<ui::KeyboardCode>(keycode),
+          control, shift, alt, meta)) {
+    reply.SendError("Could not send the native key event");
+  } else {
+    reply.SendSuccess(NULL);
+  }
 }
 
 // Sample JSON input: { "command": "GetNTPThumbnailMode" }
 // For output, refer to GetNTPThumbnailMode() in
 // chrome/test/pyautolib/pyauto.py.
 void TestingAutomationProvider::GetNTPThumbnailMode(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   const int shown_sections = ShownSectionsHandler::GetShownSections(
@@ skipping 666 matching lines @@
     // If you change this, update Observer for NotificationType::SESSION_END
     // below.
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &TestingAutomationProvider::OnRemoveProvider));
   }
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }