WebDriver extension support in TestingAutomationProvider.

chrome/browser/automation/automation_provider_json.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/browser/automation/automation_provider_json.h"
 
 #include "base/json/json_writer.h"
 #include "base/json/string_escape.h"
 #include "base/values.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/automation/automation_util.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/automation_id.h"
 #include "chrome/common/automation_messages.h"
 #include "content/browser/tab_contents/tab_contents.h"
 
 namespace {
 
 // Util for creating a JSON error return string (dict with key
 // 'error' and error string value).  No need to quote input.
 std::string JSONErrorString(const std::string& err) {
   std::string prefix = "{\"error\": \"";
@@ skipping 105 matching lines @@
     DictionaryValue* args,
     Browser** browser,
     TabContents** tab,
     std::string* error) {
   return GetBrowserFromJSONArgs(args, browser, error) &&
          GetTabFromJSONArgs(args, tab, error);
 }
 
 bool GetAutomationIdFromJSONArgs(
     DictionaryValue* args,
-    const std::string& key_name,
+    const std::string& key,
     AutomationId* id,
     std::string* error) {
   Value* id_value;
-  if (!args->Get(key_name, &id_value)) {
-    *error = base::StringPrintf("Missing parameter '%s'", key_name.c_str());
+  if (!args->Get(key, &id_value)) {
+    *error = base::StringPrintf("Missing parameter '%s'", key.c_str());
     return false;
   }
   return AutomationId::FromValue(id_value, id, error);
 }
 
 bool GetRenderViewFromJSONArgs(
     DictionaryValue* args,
     Profile* profile,
     RenderViewHost** rvh,
     std::string* error) {
   Value* id_value;
   if (args->Get("auto_id", &id_value)) {
     AutomationId id;
     if (!AutomationId::FromValue(id_value, &id, error))
       return false;
     if (!automation_util::GetRenderViewForId(id, profile, rvh)) {
       *error = "ID does not correspond to an open view";
       return false;
     }
   } else {
     // If the render view id is not specified, check for browser/tab indices.
     TabContents* tab = NULL;
     if (!GetTabFromJSONArgs(args, &tab, error))
       return false;
     *rvh = tab->render_view_host();
   }
   return true;
 }
+
+namespace {
+
+bool GetExtensionFromJSONArgsHelper(
+    base::DictionaryValue* args,
+    const std::string& key,
+    Profile* profile,
+    bool include_disabled,
+    const Extension** extension,
+    std::string* error) {
+  std::string id;
+  if (!args->GetString(key, &id)) {
+    *error = base::StringPrintf("Missing or invalid key: %s", key.c_str());
+    return false;
+  }
+  ExtensionService* service = profile->GetExtensionService();
+  if (!service) {
+    *error = "No extensions service.";
+    return false;
+  }
+  if (!service->GetInstalledExtension(id)) {
+    // The extension ID does not correspond to any extension, whether crashed
+    // or not.
+    *error = base::StringPrintf("Extension %s is not installed.",
+                                id.c_str());
+    return false;
+  }
+  const Extension* installed_extension =
+      service->GetExtensionById(id, include_disabled);
+  if (!installed_extension) {
+    *error = "Extension is disabled or has crashed.";
+    return false;
+  }
+  *extension = installed_extension;
+  return true;
+}
+
+}  // namespace
+
+bool GetExtensionFromJSONArgs(
+    base::DictionaryValue* args,
+    const std::string& key,
+    Profile* profile,
+    const Extension** extension,
+    std::string* error) {
+  return GetExtensionFromJSONArgsHelper(
+      args, key, profile, true /* include_disabled */, extension, error);
+}
+
+bool GetEnabledExtensionFromJSONArgs(
+    base::DictionaryValue* args,
+    const std::string& key,
+    Profile* profile,
+    const Extension** extension,
+    std::string* error) {
+  return GetExtensionFromJSONArgsHelper(
+      args, key, profile, false /* include_disabled */, extension, error);
+}