Small test and ChromeDriver fixes to enable additional tests.

chrome/test/webdriver/webdriver_key_converter.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/test/webdriver/webdriver_key_converter.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/test/automation/automation_json_requests.h"
 #include "chrome/test/webdriver/keycode_text_conversion.h"
@@ skipping 91 matching lines @@
 // be set.
 bool KeyCodeFromSpecialWebDriverKey(char16 key, ui::KeyboardCode* key_code) {
   int index = static_cast<int>(key) - 0xE000U;
   bool is_special_key = index >= 0 &&
       index < static_cast<int>(arraysize(kSpecialWebDriverKeys));
   if (is_special_key)
     *key_code = kSpecialWebDriverKeys[index];
   return is_special_key;
 }
 
+// Gets the key code associated with |key|, if it is a special shorthand key,
+// Shorthand keys are common text equivalents for keys, such as the newline
+// character, which is shorthand for the return key. Returns whether |key| is
+// a shorthand key. If true, |key_code| will be set and |should_skip| will be
+// set to whether the key should be skipped.
+bool KeyCodeFromShorthandKey(char16 key_utf16,
+                             ui::KeyboardCode* key_code,
+                             bool* client_should_skip) {
+  string16 key_str_utf16;
+  key_str_utf16.push_back(key_utf16);
+  std::string key_str_utf8 = UTF16ToUTF8(key_str_utf16);
+  if (key_str_utf8.length() != 1)
+    return false;
+  bool should_skip = false;
+  char key = key_str_utf8[0];
+  if (key == '\n') {

[Joe, 2011/03/15 21:22:17]

While \n is a newline for unix isn't \r\n a newline for windows?  Will the tests
just assume unix coded strings?

[kkania, 2011/03/18 21:45:12]

Yes, I support \r\n and \n. I do this by skipping \r and just doing newline on
\n.  Is that good enough?

+    *key_code = ui::VKEY_RETURN;
+  } else if (key == '\t') {
+    *key_code = ui::VKEY_TAB;
+  } else if (key == '\b') {
+    *key_code = ui::VKEY_BACK;
+  } else if (key == ' ') {
+    *key_code = ui::VKEY_SPACE;
+  } else if (key == '\r') {
+    *key_code = ui::VKEY_UNKNOWN;
+    should_skip = true;
+  } else {
+    return false;
+  }
+  *client_should_skip = should_skip;
+  return true;
+}
+
 }  // namespace
 
 namespace webdriver {
 
 WebKeyEvent CreateKeyDownEvent(ui::KeyboardCode key_code, int modifiers) {
   return WebKeyEvent(automation::kRawKeyDownType, key_code, "", "", modifiers);
 }
 
 WebKeyEvent CreateKeyUpEvent(ui::KeyboardCode key_code, int modifiers) {
   return WebKeyEvent(automation::kKeyUpType, key_code, "", "", modifiers);
@@ skipping 60 matching lines @@
         key_events->push_back(CreateKeyDownEvent(key_code, sticky_modifiers));
       else
         key_events->push_back(CreateKeyUpEvent(key_code, sticky_modifiers));
       continue;
     }
 
     ui::KeyboardCode key_code = ui::VKEY_UNKNOWN;
     std::string unmodified_text, modified_text;
     int all_modifiers = sticky_modifiers;
 
-    bool is_special_key = KeyCodeFromSpecialWebDriverKey(key, &key_code);
-    if (is_special_key && key_code == ui::VKEY_UNKNOWN) {
-      LOG(ERROR) << "Unknown WebDriver key: " << static_cast<int>(key);
-      continue;
-    }
-    if (!is_special_key) {
+    // Get the key code, text, and modifiers for the given key.
+    bool should_skip = false;
+    if (KeyCodeFromSpecialWebDriverKey(key, &key_code) ||
+        KeyCodeFromShorthandKey(key, &key_code, &should_skip)) {
+      if (should_skip)
+        continue;
+      if (key_code == ui::VKEY_UNKNOWN) {
+        LOG(ERROR) << "Unknown WebDriver key: " << static_cast<int>(key);

[Joe, 2011/03/15 21:22:17]

If an unknown key is requested shouldn't it break with an error rather than
continue?

[kkania, 2011/03/18 21:45:12]

Done.

+        continue;
+      }
+      if (key_code == ui::VKEY_RETURN) {
+        modified_text = unmodified_text = "\r";
+      } else {
+        unmodified_text = ConvertKeyCodeToText(key_code, 0);
+        modified_text = ConvertKeyCodeToText(key_code, all_modifiers);
+      }
+    } else {
       int necessary_modifiers = 0;
       ConvertCharToKeyCode(key, &key_code, &necessary_modifiers);
       all_modifiers |= necessary_modifiers;
-    }
-    if (key_code != ui::VKEY_UNKNOWN) {
-      unmodified_text = ConvertKeyCodeToText(key_code, 0);
-      modified_text = ConvertKeyCodeToText(key_code, all_modifiers);
-    }
-    if (!is_special_key && (unmodified_text.empty() || modified_text.empty())) {
-      // Do a best effort and use the raw key we were given.
-      LOG(WARNING) << "No translation for key code. Code point: "
-                   << static_cast<int>(key);
-      if (unmodified_text.empty())
-        unmodified_text = UTF16ToUTF8(keys.substr(i, 1));
-      if (modified_text.empty())
-        modified_text = UTF16ToUTF8(keys.substr(i, 1));
+      if (key_code != ui::VKEY_UNKNOWN) {
+        unmodified_text = ConvertKeyCodeToText(key_code, 0);
+        modified_text = ConvertKeyCodeToText(key_code, all_modifiers);
+      }
+      if (unmodified_text.empty() || modified_text.empty()) {
+        // Do a best effort and use the raw key we were given.
+        LOG(WARNING) << "No translation for key code. Code point: "
+                     << static_cast<int>(key);
+        if (unmodified_text.empty())
+          unmodified_text = UTF16ToUTF8(keys.substr(i, 1));
+        if (modified_text.empty())
+          modified_text = UTF16ToUTF8(keys.substr(i, 1));
+      }
     }
 
     // Create the key events.
     bool need_shift_key =
         all_modifiers & automation::kShiftKeyMask &&
         !(sticky_modifiers & automation::kShiftKeyMask);
     if (need_shift_key) {
       key_events->push_back(
           CreateKeyDownEvent(ui::VKEY_SHIFT, sticky_modifiers));
     }
 
     key_events->push_back(CreateKeyDownEvent(key_code, all_modifiers));
     if (unmodified_text.length() || modified_text.length()) {
       key_events->push_back(
           CreateCharEvent(unmodified_text, modified_text, all_modifiers));
     }
     key_events->push_back(CreateKeyUpEvent(key_code, all_modifiers));
 
     if (need_shift_key) {
       key_events->push_back(
           CreateKeyUpEvent(ui::VKEY_SHIFT, sticky_modifiers));
     }
   }
 }
 
 }  // namespace webdriver