Small test and ChromeDriver fixes to enable additional tests.

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 155 matching lines @@
   return static_cast<ErrorCode>(status);
 }
 
 ErrorCode Session::ExecuteScript(const std::string& script,
                                  const ListValue* const args,
                                  Value** value) {
   return ExecuteScript(current_target_, script, args, value);
 }
 
 ErrorCode Session::SendKeys(const WebElementId& element, const string16& keys) {
+  bool is_displayed;
+  ErrorCode code = IsElementDisplayed(current_target_, element, &is_displayed);

[dennis_jeffrey, 2011/03/23 16:57:02]

It looks like we're assuming that the IsElementDisplayed function will fill in
either "true" or "false" for the "is_displayed" variable.  I think it would be
safer to initialize "is_displayed" to "false" at line 176 above (unless C++ will
initialize it to that default value for us?).

[kkania, 2011/03/26 01:58:32]

Done.

+  if (code != kSuccess)
+    return code;
+  if (!is_displayed)
+    return kElementNotVisible;
+
   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);
+  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;
   }
 
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::SendKeysOnSessionThread,
@@ skipping 79 matching lines @@
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GetTabTitle,
       current_target_.window_id,
       tab_title,
       &success));
   return success;
 }
 
-void Session::MouseClick(const gfx::Point& click,
+bool Session::MouseClick(const gfx::Point& click,
                          automation::MouseButton button) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseClick,
       current_target_.window_id,
       click,
       button,
       &success));
+  return success;
 }
 
 bool Session::MouseMove(const gfx::Point& location) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseMove,
       current_target_.window_id,
       location,
       &success));
@@ skipping 341 matching lines @@
   ErrorCode code_top = GetElementEffectiveStyle(
       frame_id, element, "border-top-width", &border_top_str);
   if (code_left != kSuccess || code_top != kSuccess)
     return code_left;
 
   base::StringToInt(border_left_str, border_left);
   base::StringToInt(border_top_str, border_top);
   return kSuccess;
 }
 
+ErrorCode Session::IsElementDisplayed(const FrameId& frame_id,
+                                      const WebElementId& element,
+                                      bool* is_displayed) {
+  std::string script = base::StringPrintf(
+      "return (%s).apply(null, arguments);", atoms::IS_DISPLAYED);
+  ListValue args;
+  args.Append(element.ToValue());
+
+  Value* unscoped_result = NULL;
+  ErrorCode code = ExecuteScript(frame_id, script, &args, &unscoped_result);
+  scoped_ptr<Value> result(unscoped_result);
+  if (code != kSuccess)
+    return code;
+  if (!result->GetAsBoolean(is_displayed)) {
+    LOG(ERROR) << "IsDisplayed atom returned non boolean";
+    return kUnknownError;
+  }
+  return kSuccess;
+}
+
 bool Session::WaitForAllTabsToStopLoading() {
   if (!automation_.get())
     return true;
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::WaitForAllTabsToStopLoading,
       &success));
   return success;
 }
@@ skipping 38 matching lines @@
     current_target_ = FrameId(tab_ids[0], FramePath());
   }
 }
 
 void Session::TerminateOnSessionThread() {
   if (automation_.get())
     automation_->Terminate();
   automation_.reset();
 }
 
-void Session::SendKeysOnSessionThread(const string16& keys,
-                                      bool* success) {
+void Session::SendKeysOnSessionThread(const string16& keys, bool* success) {
   *success = true;
   std::vector<WebKeyEvent> key_events;
-  ConvertKeysToWebKeyEvents(keys, &key_events);
+  std::string error_msg;
+  if (!ConvertKeysToWebKeyEvents(keys, &key_events, &error_msg)) {
+    // TODO(kkania): Return this message to the user.
+    LOG(ERROR) << error_msg;
+    *success = false;
+    return;
+  }
   for (size_t i = 0; i < key_events.size(); ++i) {
     bool key_success = false;
     automation_->SendWebKeyEvent(
         current_target_.window_id, key_events[i], &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"
@@ skipping 137 matching lines @@
   if (!loc_dict->GetInteger("x", &x) ||
       !loc_dict->GetInteger("y", &y)) {
     LOG(ERROR) << "Location atom returned bad coordinate dictionary";
     code = kUnknownError;
   }
   *location = gfx::Point(x, y);
   return kSuccess;
 }
 
 }  // namespace webdriver