Allow extensions which can run without NPAPI to run under Windows 8 Metro.

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 1480 matching lines @@
         new extensions::Command(
             values::kBrowserActionCommandEvent, string16(), ""));
   }
 
   return true;
 }
 
 bool Extension::LoadPlugins(string16* error) {
   if (!manifest_->HasKey(keys::kPlugins))
     return true;
+
+  // If the extension has NPAPI plugins then by default assume it needs them.
+  requirements_.npapi = true;

[Aaron Boodman, 2012/09/19 21:34:52]

Why did you move this from LoadRequirements()? I think it's a little surprising
to modify requirements_ here.

[Wez, 2012/09/21 00:13:56]

The existing code was setting this value based on the size of |plugins_|, which
was always zero on platforms that don't support NPAPI, where LoadPlugins() won't
populate |plugins_|.

We're setting an implicit default requirement here, rather than reading from
explicitly-specified requirements, so I don't think it's such a surprise that it
be set here.

[Aaron Boodman, 2012/09/21 02:33:08]

I see. I mean, you could just check manifest->HasKey("plugins") in
LoadRequirements() too. Since that function is the one that "loads requirements"
it seems more obvious to put code that sets the requirements_ member there.

Also, nit, but I think checking HasKey("plugins") is slightly weaker than what
the code used to do. It's possible (however unwise) that there are extensions
out there with "plugins": [ ]. Right?

[Wez, 2012/09/22 07:21:00]

OK, you've convinced me.  Moved.
Possibly; the new code in LoadRequirements now copes with that case.

+
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kPlugins, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidPlugins);
     return false;
   }
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     DictionaryValue* plugin_value = NULL;
     if (!list_value->GetDictionary(i, &plugin_value)) {
       *error = ASCIIToUTF16(errors::kInvalidPlugins);
@@ skipping 10 matching lines @@
     // Get plugins[i].content (optional).
     bool is_public = false;
     if (plugin_value->HasKey(keys::kPluginsPublic)) {
       if (!plugin_value->GetBoolean(keys::kPluginsPublic, &is_public)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPluginsPublic, base::IntToString(i));
         return false;
       }
     }
 
+    // We don't allow extensions to load NPAPI plugins on Chrome OS, or under
+    // Windows 8 Metro mode, but still parse the entries to display consistent
+    // error messages. If the extension actually requires the plugins then
+    // LoadRequirements will prevent it loading.
 #if defined(OS_CHROMEOS)
-    // We don't allow extension plugins to run on Chrome OS. We still
-    // parse the manifest entry so that error messages are consistently
-    // displayed across platforms.
-#else
-#if defined(OS_WIN)
-    // Like Chrome OS, we don't support NPAPI plugins in Windows 8 metro mode
-    // but in this case we want to fail with an error.
+    continue;
+#elif defined(OS_WIN)
     if (base::win::IsMetroProcess()) {
-      *error = l10n_util::GetStringUTF16(
-          IDS_EXTENSION_INSTALL_PLUGIN_NOT_SUPPORTED);
-      return false;
+      continue;
     }
 #endif  // defined(OS_WIN).
     plugins_.push_back(PluginInfo());
     plugins_.back().path = path().Append(FilePath::FromUTF8Unsafe(path_str));
     plugins_.back().is_public = is_public;
-#endif  // defined(OS_CHROMEOS).
   }
   return true;
 }
 
 bool Extension::LoadNaClModules(string16* error) {
   if (!manifest_->HasKey(keys::kNaClModules))
     return true;
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kNaClModules, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidNaClModules);
@@ skipping 107 matching lines @@
     sandboxed_pages_content_security_policy_ =
         kDefaultSandboxedPageContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSandboxed(
         sandboxed_pages_content_security_policy_, GetType()));
   }
 
   return true;
 }
 
 bool Extension::LoadRequirements(string16* error) {
-  // If the extension has plugins, then |requirements_.npapi| defaults to true.
-  if (plugins_.size() > 0)
-    requirements_.npapi = true;
-
   if (!manifest_->HasKey(keys::kRequirements))
     return true;
 
   DictionaryValue* requirements_value = NULL;
   if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
     *error = ASCIIToUTF16(errors::kInvalidRequirements);
     return false;
   }
 
   for (DictionaryValue::key_iterator it = requirements_value->begin_keys();
@@ skipping 2331 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions