[Chromedriver] Chromedriver should handle unexpected alert automatically.

chrome/test/chromedriver/capabilities.cc

 // Copyright (c) 2013 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/chromedriver/capabilities.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/test/chromedriver/chrome/mobile_device.h"
 #include "chrome/test/chromedriver/chrome/page_load_strategy.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/logging.h"
+#include "chrome/test/chromedriver/session.h"
 
 namespace {
 
 typedef base::Callback<Status(const base::Value&, Capabilities*)> Parser;
 
 Status ParseBoolean(
     bool* to_set,
     const base::Value& option,
     Capabilities* capabilities) {
   if (!option.GetAsBoolean(to_set))
@@ skipping 147 matching lines @@
 Status ParsePageLoadStrategy(const base::Value& option,
                              Capabilities* capabilities) {
   if (!option.GetAsString(&capabilities->page_load_strategy))
     return Status(kUnknownError, "must be a string");
   if (capabilities->page_load_strategy == PageLoadStrategy::kNormal ||
       capabilities->page_load_strategy == PageLoadStrategy::kNone)
     return Status(kOk);
   return Status(kUnknownError, "page load strategy unsupported");
 }
 
+Status ParseUnexpectedAlertBehaviour(const base::Value& option,
+                             Capabilities* capabilities) {
+  if (!option.GetAsString(&capabilities->unexpected_alert_behaviour))
+    return Status(kUnknownError, "must be a string");
+  if (capabilities->unexpected_alert_behaviour == Session::kAccept ||
+      capabilities->unexpected_alert_behaviour == Session::kDismiss ||
+      capabilities->unexpected_alert_behaviour == Session::kIgnore)
+    return Status(kOk);
+  return Status(kUnknownError, "unexpected alert behaviour unsupported");
+}
+
 Status ParseSwitches(const base::Value& option,
                      Capabilities* capabilities) {
   const base::ListValue* switches_list = NULL;
   if (!option.GetAsList(&switches_list))
     return Status(kUnknownError, "must be a list");
   for (size_t i = 0; i < switches_list->GetSize(); ++i) {
     std::string arg_string;
     if (!switches_list->GetString(i, &arg_string))
       return Status(kUnknownError, "each argument must be a string");
     capabilities->switches.SetUnparsedSwitch(arg_string);
@@ skipping 410 matching lines @@
 bool Capabilities::IsRemoteBrowser() const {
   return debugger_address.IsValid();
 }
 
 Status Capabilities::Parse(const base::DictionaryValue& desired_caps) {
   std::map<std::string, Parser> parser_map;
   parser_map["chromeOptions"] = base::Bind(&ParseChromeOptions);
   parser_map["loggingPrefs"] = base::Bind(&ParseLoggingPrefs);
   parser_map["proxy"] = base::Bind(&ParseProxy);
   parser_map["pageLoadStrategy"] = base::Bind(&ParsePageLoadStrategy);
+  parser_map["unexpectedAlertBehaviour"] =
+      base::Bind(&ParseUnexpectedAlertBehaviour);
   // Network emulation requires device mode, which is only enabled when
   // mobile emulation is on.
   if (desired_caps.GetDictionary("chromeOptions.mobileEmulation", nullptr)) {
     parser_map["networkConnectionEnabled"] =
         base::Bind(&ParseBoolean, &network_emulation_enabled);
   }
   for (std::map<std::string, Parser>::iterator it = parser_map.begin();
        it != parser_map.end(); ++it) {
     const base::Value* capability = NULL;
     if (desired_caps.Get(it->first, &capability)) {
@@ skipping 10 matching lines @@
   if (iter == logging_prefs.end() || iter->second == Log::kOff) {
     const base::DictionaryValue* chrome_options = NULL;
     if (desired_caps.GetDictionary("chromeOptions", &chrome_options) &&
         chrome_options->HasKey("perfLoggingPrefs")) {
       return Status(kUnknownError, "perfLoggingPrefs specified, "
                     "but performance logging was not enabled");
     }
   }
   return Status(kOk);
 }