SupportsUserData and manifest handlers for Extension; use them for the Omnibox API.

chrome/common/extensions/extension.cc

 // Copyright (c) 2012 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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/features/simple_feature_provider.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/manifest.h"
+#include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
@@ skipping 1218 matching lines @@
     scoped_refptr<const PermissionSet> permissions) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   runtime_data_.UpdateTabSpecificPermissions(tab_id, permissions);
 }
 
 void Extension::ClearTabSpecificPermissions(int tab_id) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   runtime_data_.ClearTabSpecificPermissions(tab_id);
 }
 
+Extension::ManifestData* Extension::GetManifestData(const std::string& key)
+    const {
+  DCHECK(finished_parsing_manifest_);
+  ManifestDataMap::const_iterator iter = manifest_data_.find(key);
+  if (iter != manifest_data_.end())
+    return iter->second.get();
+  return NULL;
+}
+
+void Extension::SetManifestData(const std::string& key,
+                                Extension::ManifestData* data) {
+  DCHECK(!finished_parsing_manifest_);
+  manifest_data_[key] = linked_ptr<ManifestData>(data);
+}
+
 Extension::Location Extension::location() const {
   return manifest_->location();
 }
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
 
 const std::string Extension::VersionString() const {
   return version()->GetString();
@@ skipping 138 matching lines @@
 
 Extension::Extension(const FilePath& path,
                      scoped_ptr<extensions::Manifest> manifest)
     : manifest_version_(0),
       incognito_split_mode_(false),
       offline_enabled_(false),
       converted_from_user_script_(false),
       background_page_is_persistent_(true),
       allow_background_js_access_(true),
       manifest_(manifest.release()),
+      finished_parsing_manifest_(false),
       is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
       display_in_launcher_(true),
       display_in_new_tab_page_(true),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
   path_ = MaybeNormalizePath(path);
@@ skipping 97 matching lines @@
     return false;
   }
 
   runtime_data_.SetActivePermissions(new PermissionSet(
       this, api_permissions, host_permissions));
   required_permission_set_ = new PermissionSet(
       this, api_permissions, host_permissions);
   optional_permission_set_ = new PermissionSet(
       optional_api_permissions, optional_host_permissions, URLPatternSet());
 
+  finished_parsing_manifest_ = true;
+
   return true;
 }
 
 bool Extension::LoadAppIsolation(const APIPermissionSet& api_permissions,
                                  string16* error) {
   // Platform apps always get isolated storage.
   if (is_platform_app()) {
     is_storage_isolated_ = true;
     return true;
   }
@@ skipping 1174 matching lines @@
   }
   return true;
 }
 
 bool Extension::LoadExtensionFeatures(APIPermissionSet* api_permissions,
                                       string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
-  if (!LoadDevToolsPage(error) ||
+  if (!LoadManifestHandlerFeatures(error) ||
+      !LoadDevToolsPage(error) ||
       !LoadInputComponents(*api_permissions, error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
       !LoadBrowserAction(error) ||
       !LoadSystemIndicator(api_permissions, error) ||
       !LoadScriptBadge(error) ||
       !LoadFileBrowserHandlers(error) ||
       !LoadChromeURLOverrides(error) ||
-      !LoadOmnibox(error) ||
       !LoadTextToSpeechVoices(error) ||
       !LoadIncognitoMode(error) ||
       !LoadFileHandlers(error) ||
       !LoadContentSecurityPolicy(error))
     return false;
 
   return true;
 }
 
+bool Extension::LoadManifestHandlerFeatures(string16* error) {
+  std::vector<std::string> keys = ManifestHandler::GetKeys();
+  for (size_t i = 0; i < keys.size(); ++i) {
+    Value* value = NULL;
+    if (!manifest_->Get(keys[i], &value))
+      continue;
+    if (!ManifestHandler::Get(keys[i])->Parse(value, this, error))
+      return false;
+  }
+  return true;
+}
+
 bool Extension::LoadDevToolsPage(string16* error) {
   if (!manifest_->HasKey(keys::kDevToolsPage))
     return true;
   std::string devtools_str;
   if (!manifest_->GetString(keys::kDevToolsPage, &devtools_str)) {
     *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
     return false;
   }
   devtools_url_ = GetResourceURL(devtools_str);
   return true;
@@ skipping 532 matching lines @@
 
   // An extension may override at most one page.
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
 
   return true;
 }
 
-bool Extension::LoadOmnibox(string16* error) {
-  if (!manifest_->HasKey(keys::kOmnibox))
-    return true;
-  if (!manifest_->GetString(keys::kOmniboxKeyword, &omnibox_keyword_) ||
-      omnibox_keyword_.empty()) {
-    *error = ASCIIToUTF16(errors::kInvalidOmniboxKeyword);
-    return false;
-  }
-  return true;
-}
-
 bool Extension::LoadTextToSpeechVoices(string16* error) {
   if (!manifest_->HasKey(keys::kTtsEngine))
     return true;
   DictionaryValue* tts_dict = NULL;
   if (!manifest_->GetDictionary(keys::kTtsEngine, &tts_dict)) {
     *error = ASCIIToUTF16(errors::kInvalidTts);
     return false;
   }
 
   if (tts_dict->HasKey(keys::kTtsVoices)) {
@@ skipping 838 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions