Allow chromedriver to set local state preferences.

chrome/test/webdriver/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/webdriver_session.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 38 matching lines @@
 }
 
 FrameId& FrameId::operator=(const FrameId& other) {
   window_id = other.window_id;
   frame_path = other.frame_path;
   return *this;
 }
 
 Session::Options::Options()
     : use_native_events(false),
-      load_async(false) {
+      load_async(false),
+      no_website_testing_defaults(false) {
 }
 
 Session::Options::~Options() {
 }
 
 Session::Session(const Options& options)
     : id_(GenerateRandomID()),
       current_target_(FrameId(0, FramePath())),
       thread_(id_.c_str()),
       async_script_timeout_(0),
       implicit_wait_(0),
       has_alert_prompt_text_(false),
       options_(options) {
   SessionManager::GetInstance()->Add(this);
 }
 
 Session::~Session() {
   SessionManager::GetInstance()->Remove(id_);
 }
 
 Error* Session::Init(const Automation::BrowserOptions& options) {
   if (!thread_.Start()) {
     delete this;
     return new Error(kUnknownError, "Cannot start session thread");
   }
 
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      this,
+  RunSessionTask(base::Bind(
       &Session::InitOnSessionThread,
+      base::Unretained(this),
       options,
       &error));
+
+  if (!error)
+    error = PostBrowserStartInit();
+
   if (error)
     Terminate();
   return error;
 }
 
 Error* Session::BeforeExecuteCommand() {
   Error* error = AfterExecuteCommand();
   if (!error) {
     scoped_ptr<Error> switch_error(SwitchToTopFrameIfCurrentFrameInvalid());
     if (switch_error.get()) {
@@ skipping 13 matching lines @@
   Error* error = NULL;
   if (!options_.load_async) {
     LOG(INFO) << "Waiting for the page to stop loading";
     error = WaitForAllTabsToStopLoading();
     LOG(INFO) << "Done waiting for the page to stop loading";
   }
   return error;
 }
 
 void Session::Terminate() {
-  RunSessionTask(NewRunnableMethod(
-      this,
-      &Session::TerminateOnSessionThread));
+  RunSessionTask(base::Bind(
+      &Session::TerminateOnSessionThread,
+      base::Unretained(this)));
   delete this;
 }
 
 Error* Session::ExecuteScript(const FrameId& frame_id,
                               const std::string& script,
                               const ListValue* const args,
                               Value** value) {
   std::string args_as_json;
   base::JSONWriter::Write(static_cast<const Value* const>(args),
                           /*pretty_print=*/false,
@@ skipping 117 matching lines @@
       "    throw new Error('Failed to send keys because cannot focus element');"
       "}";
   error = ExecuteScriptAndParse(current_target_,
                                 kFocusScript,
                                 "focusElement",
                                 CreateListValueFrom(element),
                                 CreateDirectValueParser(kSkipParsing));
   if (error)
     return error;
 
-  RunSessionTask(NewRunnableMethod(
-      this,
+  RunSessionTask(base::Bind(
       &Session::SendKeysOnSessionThread,
+      base::Unretained(this),
       keys,
       &error));
   return error;
 }
 
 Error* Session::DragAndDropFilePaths(
     const Point& location,
     const std::vector<FilePath::StringType>& paths) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::DragAndDropFilePaths,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       location,
       paths,
       &error));
   return error;
 }
 
 Error* Session::NavigateToURL(const std::string& url) {
   Error* error = NULL;
   if (options_.load_async) {
-    RunSessionTask(NewRunnableMethod(
-        automation_.get(),
+    RunSessionTask(base::Bind(
         &Automation::NavigateToURLAsync,
+        base::Unretained(automation_.get()),
         current_target_.window_id,
         url,
         &error));
   } else {
-    RunSessionTask(NewRunnableMethod(
-        automation_.get(),
+    RunSessionTask(base::Bind(
         &Automation::NavigateToURL,
+        base::Unretained(automation_.get()),
         current_target_.window_id,
         url,
         &error));
   }
   return error;
 }
 
 Error* Session::GoForward() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GoForward,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       &error));
   return error;
 }
 
 Error* Session::GoBack() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GoBack,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       &error));
   return error;
 }
 
 Error* Session::Reload() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::Reload,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       &error));
   return error;
 }
 
 Error* Session::GetURL(std::string* url) {
   return ExecuteScriptAndParse(current_target_,
                                "function() { return document.URL }",
                                "getUrl",
                                new ListValue(),
@@ skipping 11 matching lines @@
   return ExecuteScriptAndParse(FrameId(current_target_.window_id, FramePath()),
                                kGetTitleScript,
                                "getTitle",
                                new ListValue(),
                                CreateDirectValueParser(tab_title));
 }
 
 Error* Session::MouseMoveAndClick(const Point& location,
                                   automation::MouseButton button) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseClick,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       location,
       button,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
 Error* Session::MouseMove(const Point& location) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseMove,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       location,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
 Error* Session::MouseDrag(const Point& start,
                           const Point& end) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseDrag,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       start,
       end,
       &error));
   if (!error)
     mouse_position_ = end;
   return error;
 }
 
 Error* Session::MouseClick(automation::MouseButton button) {
   return MouseMoveAndClick(mouse_position_, button);
 }
 
 Error* Session::MouseButtonDown() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseButtonDown,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::MouseButtonUp() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseButtonUp,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::MouseDoubleClick() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::MouseDoubleClick,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::GetCookies(const std::string& url, ListValue** cookies) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GetCookies,
+      base::Unretained(automation_.get()),
       url,
       cookies,
       &error));
   return error;
 }
 
 Error* Session::DeleteCookie(const std::string& url,
                            const std::string& cookie_name) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::DeleteCookie,
+      base::Unretained(automation_.get()),
       url,
       cookie_name,
       &error));
   return error;
 }
 
 Error* Session::SetCookie(const std::string& url,
                           DictionaryValue* cookie_dict) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::SetCookie,
+      base::Unretained(automation_.get()),
       url,
       cookie_dict,
       &error));
   return error;
 }
 
 Error* Session::GetWindowIds(std::vector<int>* window_ids) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GetTabIds,
+      base::Unretained(automation_.get()),
       window_ids,
       &error));
   return error;
 }
 
 Error* Session::SwitchToWindow(const std::string& name) {
   int switch_to_id = 0;
   int name_no = 0;
   if (base::StringToInt(name, &name_no)) {
     Error* error = NULL;
     bool does_exist = false;
-    RunSessionTask(NewRunnableMethod(
-        automation_.get(),
+    RunSessionTask(base::Bind(
         &Automation::DoesTabExist,
+        base::Unretained(automation_.get()),
         name_no,
         &does_exist,
         &error));
     if (error)
       return error;
     if (does_exist)
       switch_to_id = name_no;
   }
 
   if (!switch_to_id) {
@@ skipping 119 matching lines @@
     } else if (error.get()) {
       return error.release();
     }
     frame_path = frame_path.Append(components[i]);
   }
   return NULL;
 }
 
 Error* Session::CloseWindow() {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::CloseTab,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       &error));
 
   if (!error) {
     std::vector<int> window_ids;
     scoped_ptr<Error> error(GetWindowIds(&window_ids));
     if (error.get() || window_ids.empty()) {
       // The automation connection will soon be closed, if not already,
       // because we supposedly just closed the last window. Terminate the
       // session.
       // TODO(kkania): This will cause us problems if GetWindowIds fails for a
       // reason other than the channel is disconnected. Look into having
       // |GetWindowIds| tell us if it just closed the last window.
       Terminate();
     }
   }
   return error;
 }
 
 Error* Session::GetAlertMessage(std::string* text) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GetAppModalDialogMessage,
+      base::Unretained(automation_.get()),
       text,
       &error));
   return error;
 }
 
 Error* Session::SetAlertPromptText(const std::string& alert_prompt_text) {
   std::string message_text;
   // Only set the alert prompt text if an alert is actually active.
   Error* error = GetAlertMessage(&message_text);
   if (!error) {
     has_alert_prompt_text_ = true;
     alert_prompt_text_ = alert_prompt_text;
   }
   return error;
 }
 
 Error* Session::AcceptOrDismissAlert(bool accept) {
   Error* error = NULL;
   if (accept && has_alert_prompt_text_) {
-    RunSessionTask(NewRunnableMethod(
-        automation_.get(),
+    RunSessionTask(base::Bind(
         &Automation::AcceptPromptAppModalDialog,
+        base::Unretained(automation_.get()),
         alert_prompt_text_,
         &error));
   } else {
-    RunSessionTask(NewRunnableMethod(
-        automation_.get(),
+    RunSessionTask(base::Bind(
         &Automation::AcceptOrDismissAppModalDialog,
+        base::Unretained(automation_.get()),
         accept,
         &error));
   }
   has_alert_prompt_text_ = false;
   return error;
 }
 
 std::string Session::GetBrowserVersion() {
   std::string version;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::GetBrowserVersion,
+      base::Unretained(automation_.get()),
       &version));
   return version;
 }
 
 Error* Session::CompareBrowserVersion(int client_build_no,
                                       int client_patch_no,
                                       bool* is_newer_or_equal) {
   std::string version = GetBrowserVersion();
   std::vector<std::string> split_version;
   base::SplitString(version, '.', &split_version);
@@ skipping 275 matching lines @@
       atoms::asString(atoms::GET_ATTRIBUTE),
       "getAttribute",
       CreateListValueFrom(element, key),
       CreateDirectValueParser(value));
 }
 
 Error* Session::WaitForAllTabsToStopLoading() {
   if (!automation_.get())
     return NULL;
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::WaitForAllTabsToStopLoading,
+      base::Unretained(automation_.get()),
       &error));
   return error;
 }
 
 Error* Session::InstallExtensionDeprecated(const FilePath& path) {
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::InstallExtensionDeprecated,
+      base::Unretained(automation_.get()),
       path,
       &error));
   return error;
 }
 
 Error* Session::GetInstalledExtensions(
     std::vector<std::string>* extension_ids) {
   Error* error = NULL;
   RunSessionTask(base::Bind(
       &Automation::GetInstalledExtensions,
       base::Unretained(automation_.get()),
       extension_ids,
       &error));
   return error;
 }
 
 Error* Session::InstallExtension(
     const FilePath& path, std::string* extension_id) {
   Error* error = NULL;
   RunSessionTask(base::Bind(
       &Automation::InstallExtension,
       base::Unretained(automation_.get()),
       path,
       extension_id,
       &error));
   return error;
 }
 
+Error* Session::SetPreference(
+    const std::string& pref,
+    bool is_user_pref,
+    base::Value* value) {
+  Error* error = NULL;
+  if (is_user_pref) {
+    RunSessionTask(base::Bind(
+        &Automation::SetPreference,
+        base::Unretained(automation_.get()),
+        pref,
+        value,
+        &error));
+  } else {
+    RunSessionTask(base::Bind(
+        &Automation::SetLocalStatePreference,
+        base::Unretained(automation_.get()),
+        pref,
+        value,
+        &error));
+  }
+  return error;
+}
+
 const std::string& Session::id() const {
   return id_;
 }
 
 const FrameId& Session::current_target() const {
   return current_target_;
 }
 
 void Session::set_async_script_timeout(int timeout_ms) {
   async_script_timeout_ = timeout_ms;
@@ skipping 14 matching lines @@
 const Point& Session::get_mouse_position() const {
   return mouse_position_;
 }
 
 const Session::Options& Session::options() const {
   return options_;
 }
 
 void Session::RunSessionTask(Task* task) {
   base::WaitableEvent done_event(false, false);
-  thread_.message_loop_proxy()->PostTask(FROM_HERE, NewRunnableMethod(
-      this,
+  thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
       &Session::RunSessionTaskOnSessionThread,
+      base::Unretained(this),
       task,
       &done_event));
   done_event.Wait();
 }
 
 void Session::RunSessionTaskOnSessionThread(Task* task,
                                             base::WaitableEvent* done_event) {
   task->Run();
   delete task;
   done_event->Signal();
@@ skipping 37 matching lines @@
   if (automation_.get())
     automation_->Terminate();
   automation_.reset();
 }
 
 Error* Session::ExecuteScriptAndParseValue(const FrameId& frame_id,
                                            const std::string& script,
                                            Value** script_result) {
   std::string response_json;
   Error* error = NULL;
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::ExecuteScript,
+      base::Unretained(automation_.get()),
       frame_id.window_id,
       frame_id.frame_path,
       script,
       &response_json,
       &error));
   if (error)
     return error;
 
   scoped_ptr<Value> value(base::JSONReader::ReadAndReturnError(
       response_json, true, NULL, NULL));
@@ skipping 296 matching lines @@
 
 Error* Session::GetScreenShot(std::string* png) {
   Error* error = NULL;
   ScopedTempDir screenshots_dir;
   if (!screenshots_dir.CreateUniqueTempDir()) {
     return new Error(kUnknownError,
                      "Could not create temp directory for screenshot");
   }
 
   FilePath path = screenshots_dir.path().AppendASCII("screen");
-  RunSessionTask(NewRunnableMethod(
-      automation_.get(),
+  RunSessionTask(base::Bind(
       &Automation::CaptureEntirePageAsPNG,
+      base::Unretained(automation_.get()),
       current_target_.window_id,
       path,
       &error));
   if (error)
     return error;
   if (!file_util::ReadFileToString(path, png))
     return new Error(kUnknownError, "Could not read screenshot file");
   return NULL;
 }
 
 Error* Session::GetBrowserConnectionState(bool* online) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::IS_ONLINE),
       "isOnline",
       new ListValue(),
       CreateDirectValueParser(online));
 }
 
 Error* Session::GetAppCacheStatus(int* status) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::GET_APPCACHE_STATUS),
       "getAppcacheStatus",
       new ListValue(),
       CreateDirectValueParser(status));
 }
 
+Error* Session::PostBrowserStartInit() {
+  Error* error = NULL;
+  if (!options_.no_website_testing_defaults)
+    error = InitForWebsiteTesting();
+  if (error)
+    return error;
+
+  // Install extensions.
+  for (size_t i = 0; i < options_.extensions.size(); ++i) {
+    error = InstallExtensionDeprecated(options_.extensions[i]);
+    if (error)
+      return error;
+  }
+  return NULL;
+}
+
+Error* Session::InitForWebsiteTesting() {
+  // Disable checking for SSL certificate revocation.
+  Error* error = SetPreference(
+      "ssl.rev_checking.enabled",
+      false /* is_user_pref */,
+      Value::CreateBooleanValue(false));
+  if (error)
+    return error;
+
+  // Allow certain content by default.
+  const int kAllowContent = 1;
+  DictionaryValue* default_content_settings = new DictionaryValue();
+  default_content_settings->SetInteger("geolocation", kAllowContent);
+  default_content_settings->SetInteger("notifications", kAllowContent);
+  return SetPreference(
+      "profile.default_content_settings",
+      true /* is_user_pref */,
+      default_content_settings);
+}
+
 }  // namespace webdriver