Move page action manifest parsing out of Extension; the first multi-key manifest handler.

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 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 11 matching lines @@
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 // TODO(rdevlin.cronin): Remove this once PageAction, BrowserAction, and
 // SystemIndicator have been moved out of Extension.
 #include "chrome/common/extensions/api/extension_action/action_info.h"
+#include "chrome/common/extensions/api/extension_action/page_action_handler.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/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
@@ skipping 858 matching lines @@
   DictionaryValue* theme_images = GetThemeImages();
   if (theme_images) {
     for (DictionaryValue::Iterator it(*theme_images); !it.IsAtEnd();
          it.Advance()) {
       std::string val;
       if (it.value().GetAsString(&val))
         image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(val)));
     }
   }
 
-  if (page_action_info() && !page_action_info()->default_icon.empty()) {
+  const ActionInfo* page_action_info = ActionInfo::GetPageActionInfo(this);
+  if (page_action_info && !page_action_info->default_icon.empty()) {
     for (ExtensionIconSet::IconMap::const_iterator iter =
-             page_action_info()->default_icon.map().begin();
-         iter != page_action_info()->default_icon.map().end();
+             page_action_info->default_icon.map().begin();
+         iter != page_action_info->default_icon.map().end();
          ++iter) {
        image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
     }
   }
 
   if (browser_action_info() && !browser_action_info()->default_icon.empty()) {
     for (ExtensionIconSet::IconMap::const_iterator iter =
              browser_action_info()->default_icon.map().begin();
          iter != browser_action_info()->default_icon.map().end();
          ++iter) {
@@ skipping 1505 matching lines @@
 }
 
 bool Extension::LoadExtensionFeatures(APIPermissionSet* api_permissions,
                                       string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadManifestHandlerFeatures(error) ||
       !LoadContentScripts(error) ||
-      !LoadPageAction(error) ||
       !LoadBrowserAction(error) ||
       !LoadSystemIndicator(api_permissions, error) ||
       !LoadIncognitoMode(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)) {
       if (!ManifestHandler::Get(keys[i])->HasNoKey(this, error))
         return false;
     } else if (!ManifestHandler::Get(keys[i])->Parse(value, this, error)) {
       return false;
     }
   }
+
+  std::vector<ManifestMultiKeyHandler::KeySet> key_sets =
+      ManifestMultiKeyHandler::GetKeySets();
+  for (size_t i = 0; i < key_sets.size(); ++i) {
+    scoped_ptr<DictionaryValue> dict(new DictionaryValue);
+    // TODO(yoz): should be a const_iterator
+    for (ManifestMultiKeyHandler::KeySet::iterator ki = key_sets[i].begin();
+         ki != key_sets[i].end(); ++ki) {
+      Value* value = NULL;
+      if (manifest_->Get(*ki, &value)) {
+        dict->Set(*ki, value->DeepCopy());
+      }
+      if (!ManifestMultiKeyHandler::Get(key_sets[i])->Parse(
+              dict.get(), this, error))
+        return false;
+    }
+  }
+
   return true;
 }
 
 bool Extension::LoadContentScripts(string16* error) {
   if (!manifest_->HasKey(keys::kContentScripts))
     return true;
   ListValue* list_value;
   if (!manifest_->GetList(keys::kContentScripts, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidContentScriptsList);
     return false;
@@ skipping 13 matching lines @@
     script.set_extension_id(id());
     if (converted_from_user_script_) {
       script.set_emulate_greasemonkey(true);
       script.set_match_all_frames(true);  // Greasemonkey matches all frames.
     }
     content_scripts_.push_back(script);
   }
   return true;
 }
 
-bool Extension::LoadPageAction(string16* error) {
-  DictionaryValue* page_action_value = NULL;
-
-  if (manifest_->HasKey(keys::kPageActions)) {
-    ListValue* list_value = NULL;
-    if (!manifest_->GetList(keys::kPageActions, &list_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionsList);
-      return false;
-    }
-
-    size_t list_value_length = list_value->GetSize();
-
-    if (list_value_length == 0u) {
-      // A list with zero items is allowed, and is equivalent to not having
-      // a page_actions key in the manifest.  Don't set |page_action_value|.
-    } else if (list_value_length == 1u) {
-      if (!list_value->GetDictionary(0, &page_action_value)) {
-        *error = ASCIIToUTF16(errors::kInvalidPageAction);
-        return false;
-      }
-    } else {  // list_value_length > 1u.
-      *error = ASCIIToUTF16(errors::kInvalidPageActionsListSize);
-      return false;
-    }
-  } else if (manifest_->HasKey(keys::kPageAction)) {
-    if (!manifest_->GetDictionary(keys::kPageAction, &page_action_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageAction);
-      return false;
-    }
-  }
-
-  // If page_action_value is not NULL, then there was a valid page action.
-  if (page_action_value) {
-    page_action_info_ = LoadExtensionActionInfoHelper(
-        this, page_action_value, error);
-    if (!page_action_info_.get())
-      return false;  // Failed to parse page action definition.
-  }
-
-  return true;
-}
-
 bool Extension::LoadBrowserAction(string16* error) {
   if (!manifest_->HasKey(keys::kBrowserAction))
     return true;
   DictionaryValue* browser_action_value = NULL;
   if (!manifest_->GetDictionary(keys::kBrowserAction, &browser_action_value)) {
     *error = ASCIIToUTF16(errors::kInvalidBrowserAction);
     return false;
   }
 
   browser_action_info_ = LoadExtensionActionInfoHelper(
@@ skipping 481 matching lines @@
     }
     oauth2_info_.scopes.push_back(scope);
   }
 
   return true;
 }
 
 bool Extension::HasMultipleUISurfaces() const {
   int num_surfaces = 0;
 
-  if (page_action_info())
+  if (ActionInfo::GetPageActionInfo(this))
     ++num_surfaces;
 
   if (browser_action_info())
     ++num_surfaces;
 
   if (is_app())
     ++num_surfaces;
 
   return num_surfaces > 1;
 }
@@ skipping 167 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions