Add a launchApp method to extension management API....

chrome/browser/extensions/extension_management_api.cc

 // Copyright (c) 2010 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/extensions/extension_management_api.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 20 matching lines @@
 
 const char kAppLaunchUrlKey[] = "appLaunchUrl";
 const char kEnabledKey[] = "enabled";
 const char kIconsKey[] = "icons";
 const char kIdKey[] = "id";
 const char kIsAppKey[] = "isApp";
 const char kNameKey[] = "name";
 const char kOptionsUrlKey[] = "optionsUrl";
 const char kSizeKey[] = "size";
 const char kUrlKey[] = "url";
+const char kVersionKey[] = "version";
 
 const char kNoExtensionError[] = "No extension with id *";
-
+const char kNotAnAppError[] = "Extension * is not an App";
 }
 
 ExtensionsService* ExtensionManagementFunction::service() {
   return profile()->GetExtensionsService();
 }
 
 static DictionaryValue* CreateExtensionInfo(const Extension& extension,
                                             bool enabled) {
   DictionaryValue* info = new DictionaryValue();
   info->SetString(kIdKey, extension.id());
   info->SetBoolean(kIsAppKey, extension.is_app());
   info->SetString(kNameKey, extension.name());
   info->SetBoolean(kEnabledKey, enabled);
+  info->SetString(kVersionKey, extension.VersionString());
   if (!extension.options_url().is_empty())
     info->SetString(kOptionsUrlKey,
                     extension.options_url().possibly_invalid_spec());
   if (extension.is_app())
     info->SetString(kAppLaunchUrlKey,
                     extension.GetFullLaunchURL().possibly_invalid_spec());
 
   const ExtensionIconSet::IconMap& icons = extension.icons().map();
   if (!icons.empty()) {
     ListValue* icon_list = new ListValue();
@@ skipping 28 matching lines @@
 bool GetAllExtensionsFunction::RunImpl() {
   ListValue* result = new ListValue();
   result_.reset(result);
 
   AddExtensionInfo(result, *service()->extensions(), true);
   AddExtensionInfo(result, *service()->disabled_extensions(), false);
 
   return true;
 }
 
+bool LaunchAppFunction::RunImpl() {
+  std::string extension_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
+  Extension* extension = service()->GetExtensionById(extension_id, true);
+  if (!extension) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNoExtensionError,
+                                                     extension_id);
+    return false;
+  }
+  if (!extension->is_app()) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNotAnAppError,
+                                                     extension_id);
+    return false;
+  }
+
+  extension_misc::LaunchContainer container = extension->launch_container();
+  Browser::OpenApplication(profile(), extension, container);
+
+  return true;
+}
+
 bool SetEnabledFunction::RunImpl() {
   std::string extension_id;
   bool enable;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &enable));
 
   if (!service()->GetExtensionById(extension_id, true)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         kNoExtensionError, extension_id);
     return false;
@@ skipping 85 matching lines @@
   std::string args_json;
   base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
 
   ExtensionMessageService* message_service =
       profile->GetExtensionMessageService();
   message_service->DispatchEventToRenderers(event_name,
                                             args_json,
                                             profile,
                                             GURL());
 }