Allow chromedriver to install an extension and get all installed extension IDs.

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"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/process.h"
 #include "base/process_util.h"
@@ skipping 970 matching lines @@
   if (!automation_.get())
     return NULL;
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::WaitForAllTabsToStopLoading,
       &error));
   return error;
 }
 
-Error* Session::InstallExtension(const FilePath& path) {
+Error* Session::InstallExtensionDeprecated(const FilePath& path) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
-      &Automation::InstallExtension,
+      &Automation::InstallExtensionDeprecated,
       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;
+}
 
 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) {
@@ skipping 30 matching lines @@
   done_event.Wait();
 }
 
 void Session::RunSessionTaskOnSessionThread(Task* task,
                                             base::WaitableEvent* done_event) {
   task->Run();
   delete task;
   done_event->Signal();
 }
 
+void Session::RunSessionTask(const base::Closure& task) {
+  base::WaitableEvent done_event(false, false);
+  thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
+      &Session::RunClosureOnSessionThread,
+      base::Unretained(this),
+      task,
+      &done_event));
+  done_event.Wait();
+}
+
+void Session::RunClosureOnSessionThread(const base::Closure& task,
+                                        base::WaitableEvent* done_event) {
+  task.Run();
+  done_event->Signal();
+}
 
 void Session::InitOnSessionThread(const Automation::BrowserOptions& options,
                                   Error** error) {
   automation_.reset(new Automation());
   automation_->Init(options, error);
   if (*error)
     return;
 
   std::vector<int> tab_ids;
   automation_->GetTabIds(&tab_ids, error);
@@ skipping 361 matching lines @@
 Error* Session::GetAppCacheStatus(int* status) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::GET_APPCACHE_STATUS),
       "getAppcacheStatus",
       new ListValue(),
       CreateDirectValueParser(status));
 }
 
 }  // namespace webdriver