Fix minor issues in ChromeDriver.

chrome/test/webdriver/automation.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/automation.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/string_number_conversions.h"
+#include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/automation/automation_json_requests.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "chrome/test/automation/proxy_launcher.h"
@@ skipping 136 matching lines @@
   };
 
   if (!launcher_->LaunchBrowserAndServer(launch_props, true)) {
     *error = new Error(
         kUnknownError,
         "Unable to either launch or connect to Chrome. Please check that "
             "ChromeDriver is up-to-date");
     return;
   }
 
-  int version = 0;
-  std::string error_msg;
-  if (!SendGetChromeDriverAutomationVersion(
-          automation(), &version, &error_msg)) {
-    *error = CreateChromeError(error_msg);
+  bool has_automation_version = false;
+  *error = CompareVersion(730, 0, &has_automation_version);
+  if (*error)
     return;
-  }
-  if (version > automation::kChromeDriverAutomationVersion) {
-    *error = new Error(
-        kUnknownError,
-        "ChromeDriver is not compatible with this version of Chrome.");
-    return;
+  if (has_automation_version) {
+    int version = 0;
+    std::string error_msg;
+    if (!SendGetChromeDriverAutomationVersion(
+            automation(), &version, &error_msg)) {
+      *error = CreateChromeError(error_msg);
+      return;
+    }
+    if (version > automation::kChromeDriverAutomationVersion) {
+      *error = new Error(
+          kUnknownError,
+          "ChromeDriver is not compatible with this version of Chrome.");
+      return;
+    }
   }
 }
 
 void Automation::Terminate() {
   if (launcher_.get() && launcher_->process() != base::kNullProcessHandle) {
     launcher_->QuitBrowser();
   }
 }
 
 void Automation::ExecuteScript(int tab_id,
@@ skipping 62 matching lines @@
   std::string error_msg;
   if (!SendMouseDragJSONRequest(automation(), windex, tab_index, start.x(),
                                 start.y(), end.x(), end.y(), &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::MouseButtonUp(int tab_id,
                                const gfx::Point& p,
                                Error** error) {
+  *error = CheckAdvancedInteractionsSupported();
+  if (*error)
+    return;
+
   int windex = 0, tab_index = 0;
   *error = GetIndicesForTab(tab_id, &windex, &tab_index);
   if (*error)
     return;
 
   std::string error_msg;
   if (!SendMouseButtonUpJSONRequest(
           automation(), windex, tab_index, p.x(), p.y(), &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::MouseButtonDown(int tab_id,
                                  const gfx::Point& p,
                                  Error** error) {
+  *error = CheckAdvancedInteractionsSupported();
+  if (*error)
+    return;
+
   int windex = 0, tab_index = 0;
   *error = GetIndicesForTab(tab_id, &windex, &tab_index);
   if (*error)
     return;
 
   std::string error_msg;
   if (!SendMouseButtonDownJSONRequest(
           automation(), windex, tab_index, p.x(), p.y(), &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::MouseDoubleClick(int tab_id,
                                   const gfx::Point& p,
                                   Error** error) {
+  *error = CheckAdvancedInteractionsSupported();
+  if (*error)
+    return;
+
   int windex = 0, tab_index = 0;
   *error = GetIndicesForTab(tab_id, &windex, &tab_index);
   if (*error)
     return;
 
   std::string error_msg;
   if (!SendMouseDoubleClickJSONRequest(
           automation(), windex, tab_index, p.x(), p.y(), &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
@@ skipping 198 matching lines @@
   *error = GetIndicesForTab(tab_id, &windex, &tab_index);
   if (*error)
     return;
 
   std::string error_msg;
   if (!SendCloseTabJSONRequest(automation(), windex, tab_index, &error_msg))
     *error = CreateChromeError(error_msg);
 }
 
 void Automation::GetAppModalDialogMessage(std::string* message, Error** error) {
+  *error = CheckAlertsSupported();
+  if (*error)
+    return;
+
   std::string error_msg;
   if (!SendGetAppModalDialogMessageJSONRequest(
           automation(), message, &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::AcceptOrDismissAppModalDialog(bool accept, Error** error) {
+  *error = CheckAlertsSupported();
+  if (*error)
+    return;
+
   std::string error_msg;
   if (!SendAcceptOrDismissAppModalDialogJSONRequest(
           automation(), accept, &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::AcceptPromptAppModalDialog(const std::string& prompt_text,
                                             Error** error) {
+  *error = CheckAlertsSupported();
+  if (*error)
+    return;
+
   std::string error_msg;
   if (!SendAcceptPromptAppModalDialogJSONRequest(
           automation(), prompt_text, &error_msg)) {
     *error = CreateChromeError(error_msg);
   }
 }
 
 void Automation::GetBrowserVersion(std::string* version) {
   *version = automation()->server_version();
 }
@@ skipping 21 matching lines @@
           automation(), tab_id, browser_index, tab_index, &error_msg)) {
     return CreateChromeError(error_msg);
   }
   return NULL;
 }
 
 Error* Automation::CreateChromeError(const std::string& message) {
   return new Error(kUnknownError, "Internal Chrome error: " + message);
 }
 
+Error* Automation::CompareVersion(int client_build_no,
+                                  int client_patch_no,
+                                  bool* is_newer_or_equal) {
+  std::string version = automation()->server_version();
+  std::vector<std::string> split_version;
+  base::SplitString(version, '.', &split_version);
+  if (split_version.size() != 4) {
+    return new Error(
+        kUnknownError, "Browser version has unrecognized format: " + version);
+  }
+  int build_no, patch_no;
+  if (!base::StringToInt(split_version[2], &build_no) ||
+      !base::StringToInt(split_version[3], &patch_no)) {
+    return new Error(
+        kUnknownError, "Browser version has unrecognized format: " + version);
+  }
+  if (build_no < client_build_no)
+    *is_newer_or_equal = false;
+  else if (build_no > client_build_no)
+    *is_newer_or_equal = true;
+  else
+    *is_newer_or_equal = patch_no >= client_patch_no;
+  return NULL;
+}
+
+Error* Automation::CheckVersion(int client_build_no,
+                                int client_patch_no,
+                                const std::string& error_msg) {
+  bool version_is_ok = false;
+  Error* error = CompareVersion(
+      client_build_no, client_patch_no, &version_is_ok);
+  if (error)
+    return error;
+  if (!version_is_ok)
+    return new Error(kUnknownError, error_msg);
+  return NULL;
+}
+
+Error* Automation::CheckAlertsSupported() {
+  return CheckVersion(
+      768, 0, "Alerts are not supported for this version of Chrome");
+}
+
+Error* Automation::CheckAdvancedInteractionsSupported() {
+  const char* message =
+      "Advanced user interactions are not supported for this version of Chrome";
+  return CheckVersion(750, 0, message);
+}
+
 }  // namespace webdriver