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

chrome/test/webdriver/session.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/session_manager.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 144 matching lines @@
 }
 
 ErrorCode Session::ExecuteScript(const std::string& script,
                                  const ListValue* const args,
                                  Value** value) {
   return ExecuteScript(
       current_window_id_, current_frame_xpath_, script, args, value);
 }
 
 ErrorCode Session::SendKeys(const WebElementId& element, const string16& keys) {
-  ListValue args;
-  args.Append(element.ToValue());
-  // TODO(jleyba): Update this to use the correct atom.
-  std::string script = "document.activeElement.blur();arguments[0].focus();";
-  Value* unscoped_result = NULL;
-  ErrorCode code = ExecuteScript(script, &args, &unscoped_result);
-  scoped_ptr<Value> result(unscoped_result);
-  if (code != kSuccess) {
-    LOG(ERROR) << "Failed to focus element before sending keys";
-    return code;
+  // This method will first check if the element we want to send the keys to is
+  // already focused, if not it will try to focus on it first.
+  scoped_ptr<ListValue> nullArgs(new ListValue);

[Jason Leyba, 2011/03/04 19:25:12]

This would be much simpler if you did it all with one ExecuteScript call

if (document.activeElement != arguments[0]) {
  if (document.activeElement)
      document.activeElement.blur();
  arguments[0].focus();
}

[timothe faudot, 2011/03/07 02:45:26]

Done.

+  Value* active_element = NULL;
+  ErrorCode status = ExecuteScript(
+      "return document.activeElement;", nullArgs.get(), &active_element);
+  if (status != kSuccess) {
+    LOG(ERROR) << "Failed to get which element was focused before sending keys";
+    return status;
   }
-
+  if (active_element == NULL ||
+      active_element->GetType() != Value::TYPE_DICTIONARY) {
+    LOG(ERROR) << "Expected Japascript to return a dictionary";
+    return kUnknownError;
+  }
+  std::string active_elem_str;
+  static_cast<DictionaryValue*>(active_element)->GetString("ELEMENT",
+                                                           &active_elem_str);
+  std::string wanted_element;
+  DictionaryValue* element_id =
+      static_cast<DictionaryValue*>(element.ToValue());
+  element_id->GetString("ELEMENT", &wanted_element);
+  // We focus on the element only if necessary.
+  if (active_elem_str != wanted_element) {
+    scoped_ptr<ListValue> args(new ListValue);
+    args->Append(element.ToValue());
+    // TODO(jleyba): Update this to use the correct atom.
+    std::string script = "document.activeElement.blur();arguments[0].focus();";
+    Value* unscoped_result = NULL;
+    ErrorCode code = ExecuteScript(script, args.get(), &unscoped_result);
+    if (code != kSuccess) {
+      LOG(ERROR) << "Failed to focus element before sending keys";
+      return code;
+    }
+  }
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::SendKeysOnSessionThread,
       keys,
       &success));
   if (!success)
     return kUnknownError;
   return kSuccess;
 }
@@ skipping 417 matching lines @@
 }
 
 void Session::SendKeysOnSessionThread(const string16& keys,
                                       bool* success) {
   *success = true;
   std::vector<WebKeyEvent> key_events;
   ConvertKeysToWebKeyEvents(keys, &key_events);
   for (size_t i = 0; i < key_events.size(); ++i) {
     bool key_success = false;
     automation_->SendWebKeyEvent(
-        current_window_id_, key_events[i], &key_success);
-    if (!key_success) {
+        current_window_id_, key_events[i],
+        SessionManager::GetInstance()->use_native_events(), &key_success);
+      if (!key_success) {
       LOG(ERROR) << "Failed to send key event. Event details:\n"
                  << "Type: " << key_events[i].type << "\n"
                  << "KeyCode: " << key_events[i].key_code << "\n"
                  << "UnmodifiedText: " << key_events[i].unmodified_text << "\n"
                  << "ModifiedText: " << key_events[i].modified_text << "\n"
                  << "Modifiers: " << key_events[i].modifiers << "\n";
       *success = false;
     }
   }
 }
@@ skipping 134 matching lines @@
       }
     } else {
       LOG(ERROR) << "Location atom returned non-dictionary type";
       code = kUnknownError;
     }
   }
   return code;
 }
 
 }  // namespace webdriver