Add nacl_modules key to extension manifests

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 1600 matching lines @@
 
   // Initialize themes (if present).
   is_theme_ = false;
   if (source.HasKey(keys::kTheme)) {
     // Themes cannot contain extension keys.
     if (ContainsNonThemeKeys(source)) {
       *error = errors::kThemesCannotContainExtensions;
       return false;
     }
 
-    DictionaryValue* theme_value;
+    DictionaryValue* theme_value = NULL;
     if (!source.GetDictionary(keys::kTheme, &theme_value)) {
       *error = errors::kInvalidTheme;
       return false;
     }
     is_theme_ = true;
 
-    DictionaryValue* images_value;
+    DictionaryValue* images_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
       // Validate that the images are all strings
       for (DictionaryValue::key_iterator iter = images_value->begin_keys();
            iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (!images_value->GetString(*iter, &val)) {
           *error = errors::kInvalidThemeImages;
           return false;
         }
       }
       theme_images_.reset(images_value->DeepCopy());
     }
 
-    DictionaryValue* colors_value;
+    DictionaryValue* colors_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
       // Validate that the colors are RGB or RGBA lists
       for (DictionaryValue::key_iterator iter = colors_value->begin_keys();
            iter != colors_value->end_keys(); ++iter) {
-        ListValue* color_list;
-        double alpha;
-        int alpha_int;
-        int color;
+        ListValue* color_list = NULL;
+        double alpha = 0.0;
+        int alpha_int = 0;
+        int color = 0;
         // The color must be a list
         if (!colors_value->GetListWithoutPathExpansion(*iter, &color_list) ||
             // And either 3 items (RGB) or 4 (RGBA)
             ((color_list->GetSize() != 3) &&
              ((color_list->GetSize() != 4) ||
               // For RGBA, the fourth item must be a real or int alpha value
               (!color_list->GetDouble(3, &alpha) &&
                !color_list->GetInteger(3, &alpha_int)))) ||
             // For both RGB and RGBA, the first three items must be ints (R,G,B)
             !color_list->GetInteger(0, &color) ||
             !color_list->GetInteger(1, &color) ||
             !color_list->GetInteger(2, &color)) {
           *error = errors::kInvalidThemeColors;
           return false;
         }
       }
       theme_colors_.reset(colors_value->DeepCopy());
     }
 
-    DictionaryValue* tints_value;
+    DictionaryValue* tints_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeTints, &tints_value)) {
       // Validate that the tints are all reals.
       for (DictionaryValue::key_iterator iter = tints_value->begin_keys();
            iter != tints_value->end_keys(); ++iter) {
-        ListValue* tint_list;
-        double v;
-        int vi;
+        ListValue* tint_list = NULL;
+        double v = 0.0;
+        int vi = 0;
         if (!tints_value->GetListWithoutPathExpansion(*iter, &tint_list) ||
             tint_list->GetSize() != 3 ||
             !(tint_list->GetDouble(0, &v) || tint_list->GetInteger(0, &vi)) ||
             !(tint_list->GetDouble(1, &v) || tint_list->GetInteger(1, &vi)) ||
             !(tint_list->GetDouble(2, &v) || tint_list->GetInteger(2, &vi))) {
           *error = errors::kInvalidThemeTints;
           return false;
         }
       }
       theme_tints_.reset(tints_value->DeepCopy());
     }
 
-    DictionaryValue* display_properties_value;
+    DictionaryValue* display_properties_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
         &display_properties_value)) {
       theme_display_properties_.reset(
           display_properties_value->DeepCopy());
     }
 
     return true;
   }
 
   // Initialize plugins (optional).
   if (source.HasKey(keys::kPlugins)) {
-    ListValue* list_value;
+    ListValue* list_value = NULL;
     if (!source.GetList(keys::kPlugins, &list_value)) {
       *error = errors::kInvalidPlugins;
       return false;
     }
 
 #if defined(OS_CHROMEOS)
     if (list_value->GetSize() > 0) {
       *error = errors::kIllegalPlugins;
       return false;
     }
 #endif
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
-      DictionaryValue* plugin_value;
+      DictionaryValue* plugin_value = NULL;
       std::string path_str;
       bool is_public = false;
 
       if (!list_value->GetDictionary(i, &plugin_value)) {
         *error = errors::kInvalidPlugins;
         return false;
       }
 
       // Get plugins[i].path.
       if (!plugin_value->GetString(keys::kPluginsPath, &path_str)) {
@@ skipping 10 matching lines @@
           return false;
         }
       }
 
       plugins_.push_back(PluginInfo());
       plugins_.back().path = path().AppendASCII(path_str);
       plugins_.back().is_public = is_public;
     }
   }
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalExtensionApis) &&
+      source.HasKey(keys::kNaClModules)) {
+    ListValue* list_value = NULL;
+    if (!source.GetList(keys::kNaClModules, &list_value)) {
+      *error = errors::kInvalidNaClModules;
+      return false;
+    }
+
+    for (size_t i = 0; i < list_value->GetSize(); ++i) {
+      DictionaryValue* module_value = NULL;
+      std::string path_str;
+      std::string mime_type;
+
+      if (!list_value->GetDictionary(i, &module_value)) {
+        *error = errors::kInvalidNaClModules;
+        return false;
+      }
+
+      // Get nacl_modules[i].path.
+      if (!module_value->GetString(keys::kNaClModulesPath, &path_str)) {
+        *error = ExtensionErrorUtils::FormatErrorMessage(
+            errors::kInvalidNaClModulesPath, base::IntToString(i));
+        return false;
+      }
+
+      // Get nacl_modules[i].mime_type.
+      if (!module_value->GetString(keys::kNaClModulesMIMEType, &mime_type)) {
+        *error = ExtensionErrorUtils::FormatErrorMessage(
+            errors::kInvalidNaClModulesMIMEType, base::IntToString(i));
+        return false;
+      }
+
+      nacl_modules_.push_back(NaClModuleInfo());
+      nacl_modules_.back().path = path().AppendASCII(path_str);
+      nacl_modules_.back().mime_type = mime_type;
+    }
+  }
+
   // Initialize background url (optional).
   if (source.HasKey(keys::kBackground)) {
     std::string background_str;
     if (!source.GetString(keys::kBackground, &background_str)) {
       *error = errors::kInvalidBackground;
       return false;
     }
     background_url_ = GetResourceURL(background_str);
   }
 
   // Initialize toolstrips.  This is deprecated for public use.
   // NOTE(erikkay) Although deprecated, we intend to preserve this parsing
   // code indefinitely.  Please contact me or Joi for details as to why.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalExtensionApis) &&
       source.HasKey(keys::kToolstrips)) {
-    ListValue* list_value;
+    ListValue* list_value = NULL;
     if (!source.GetList(keys::kToolstrips, &list_value)) {
       *error = errors::kInvalidToolstrips;
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       GURL toolstrip;
-      DictionaryValue* toolstrip_value;
+      DictionaryValue* toolstrip_value = NULL;
       std::string toolstrip_path;
       if (list_value->GetString(i, &toolstrip_path)) {
         // Support a simple URL value for backwards compatibility.
         toolstrip = GetResourceURL(toolstrip_path);
       } else if (list_value->GetDictionary(i, &toolstrip_value)) {
         if (!toolstrip_value->GetString(keys::kToolstripPath,
                                         &toolstrip_path)) {
           *error = ExtensionErrorUtils::FormatErrorMessage(
               errors::kInvalidToolstrip, base::IntToString(i));
           return false;
@@ skipping 10 matching lines @@
 
   // Initialize content scripts (optional).
   if (source.HasKey(keys::kContentScripts)) {
     ListValue* list_value;
     if (!source.GetList(keys::kContentScripts, &list_value)) {
       *error = errors::kInvalidContentScriptsList;
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
-      DictionaryValue* content_script;
+      DictionaryValue* content_script = NULL;
       if (!list_value->GetDictionary(i, &content_script)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidContentScript, base::IntToString(i));
         return false;
       }
 
       UserScript script;
       if (!LoadUserScriptHelper(content_script, i, flags, error, &script))
         return false;  // Failed to parse script context definition.
       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);
     }
   }
 
   // Initialize page action (optional).
   DictionaryValue* page_action_value = NULL;
 
   if (source.HasKey(keys::kPageActions)) {
-    ListValue* list_value;
+    ListValue* list_value = NULL;
     if (!source.GetList(keys::kPageActions, &list_value)) {
       *error = 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|.
@@ skipping 16 matching lines @@
   // If page_action_value is not NULL, then there was a valid page action.
   if (page_action_value) {
     page_action_.reset(
         LoadExtensionActionHelper(page_action_value, error));
     if (!page_action_.get())
       return false;  // Failed to parse page action definition.
   }
 
   // Initialize browser action (optional).
   if (source.HasKey(keys::kBrowserAction)) {
-    DictionaryValue* browser_action_value;
+    DictionaryValue* browser_action_value = NULL;
     if (!source.GetDictionary(keys::kBrowserAction, &browser_action_value)) {
       *error = errors::kInvalidBrowserAction;
       return false;
     }
 
     browser_action_.reset(
         LoadExtensionActionHelper(browser_action_value, error));
     if (!browser_action_.get())
       return false;  // Failed to parse browser action definition.
   }
@@ skipping 138 matching lines @@
   if (source.HasKey(keys::kDefaultLocale)) {
     if (!source.GetString(keys::kDefaultLocale, &default_locale_) ||
         !l10n_util::IsValidLocaleSyntax(default_locale_)) {
       *error = errors::kInvalidDefaultLocale;
       return false;
     }
   }
 
   // Chrome URL overrides (optional)
   if (source.HasKey(keys::kChromeURLOverrides)) {
-    DictionaryValue* overrides;
+    DictionaryValue* overrides = NULL;
     if (!source.GetDictionary(keys::kChromeURLOverrides, &overrides)) {
       *error = errors::kInvalidChromeURLOverrides;
       return false;
     }
 
     // Validate that the overrides are all strings
     for (DictionaryValue::key_iterator iter = overrides->begin_keys();
          iter != overrides->end_keys(); ++iter) {
       std::string page = *iter;
       std::string val;
@@ skipping 39 matching lines @@
     }
     if (!HasApiPermission(Extension::kExperimentalPermission)) {
       *error = errors::kDevToolsExperimental;
       return false;
     }
     devtools_url_ = GetResourceURL(devtools_str);
   }
 
   // Initialize sidebar action (optional).
   if (source.HasKey(keys::kSidebar)) {
-    DictionaryValue* sidebar_value;
+    DictionaryValue* sidebar_value = NULL;
     if (!source.GetDictionary(keys::kSidebar, &sidebar_value)) {
       *error = errors::kInvalidSidebar;
       return false;
     }
     if (!HasApiPermission(Extension::kExperimentalPermission)) {
       *error = errors::kSidebarExperimental;
       return false;
     }
     sidebar_defaults_.reset(LoadExtensionSidebarDefaults(sidebar_value, error));
     if (!sidebar_defaults_.get())
       return false;  // Failed to parse sidebar definition.
   }
 
   // Initialize text-to-speech voices (optional).
   if (source.HasKey(keys::kTts)) {
-    DictionaryValue* tts_dict;
+    DictionaryValue* tts_dict = NULL;
     if (!source.GetDictionary(keys::kTts, &tts_dict)) {
       *error = errors::kInvalidTts;
       return false;
     }
 
     if (tts_dict->HasKey(keys::kTtsVoices)) {
-      ListValue* tts_voices;
+      ListValue* tts_voices = NULL;
       if (!tts_dict->GetList(keys::kTtsVoices, &tts_voices)) {
         *error = errors::kInvalidTtsVoices;
         return false;
       }
 
       for (size_t i = 0; i < tts_voices->GetSize(); i++) {
-        DictionaryValue* one_tts_voice;
+        DictionaryValue* one_tts_voice = NULL;
         if (!tts_voices->GetDictionary(i, &one_tts_voice)) {
           *error = errors::kInvalidTtsVoices;
           return false;
         }
 
         TtsVoice voice_data;
         if (one_tts_voice->HasKey(keys::kTtsVoicesVoiceName)) {
           if (!one_tts_voice->GetString(
                   keys::kTtsVoicesVoiceName, &voice_data.voice_name)) {
             *error = errors::kInvalidTtsVoicesVoiceName;
@@ skipping 487 matching lines @@
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}