Cache --whitelisted-extension-id in SimpleFeature.

extensions/common/features/simple_feature.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/switches.h"
 
 namespace extensions {
 
+// static
+std::string* SimpleFeature::whitelisted_extension_id_ = NULL;
+
 namespace {
 
 Feature::Availability IsAvailableToManifestForBind(
     const std::string& extension_id,
     Manifest::Type type,
     Manifest::Location location,
     int manifest_version,
     Feature::Platform platform,
     const Feature* feature) {
   return feature->IsAvailableToManifest(
@@ skipping 302 matching lines @@
   if (IsIdInBlacklist(extension_id))
     return CreateAvailability(FOUND_IN_BLACKLIST, type);
 
   // TODO(benwells): don't grant all component extensions.
   // See http://crbug.com/370375 for more details.
   // Component extensions can access any feature.
   // NOTE: Deliberately does not match EXTERNAL_COMPONENT.
   if (component_extensions_auto_granted_ && location == Manifest::COMPONENT)
     return CreateAvailability(IS_AVAILABLE, type);
 
-  if (!whitelist_.empty()) {
-    if (!IsIdInWhitelist(extension_id)) {
-      // TODO(aa): This is gross. There should be a better way to test the
-      // whitelist.
-      base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-      if (!command_line->HasSwitch(switches::kWhitelistedExtensionID))
-        return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
-
-      std::string whitelist_switch_value =
-          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              switches::kWhitelistedExtensionID);
-      if (extension_id != whitelist_switch_value)
-        return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
-    }
+  if (!whitelist_.empty() && !IsIdInWhitelist(extension_id) &&
+      extension_id != whitelisted_extension_id()) {

[tapted, 2015/03/31 03:26:49]

I'm not sure we know for certain whether `extension_id` is an empty string here.
If it is, and there's no --whitelisted-extension-id, it will get whitelisted.
IsIdInWhitelist has a validity check on the id string, so I'm suspicious...

[jackhou1, 2015/03/31 04:37:45]

Added check for empty whitelisted_extension_id.

+    return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
   }
 
   if (!MatchesManifestLocation(location))
     return CreateAvailability(INVALID_LOCATION, type);
 
   if (!platforms_.empty() && !ContainsKey(platforms_, platform))
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
@@ skipping 205 matching lines @@
         ExtensionAPI::GetSharedInstance()->GetFeatureDependency(dep_name);
     if (!dependency)
       return CreateAvailability(NOT_PRESENT);
     Availability dependency_availability = checker.Run(dependency);
     if (!dependency_availability.is_available())
       return dependency_availability;
   }
   return CreateAvailability(IS_AVAILABLE);
 }
 
+// static
+const std::string& SimpleFeature::whitelisted_extension_id() {
+  if (!whitelisted_extension_id_) {

[tapted, 2015/03/31 03:26:49]

use

  CR_DEFINE_STATIC_LOCAL(std::string, whitelisted_extension_id, (
      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
          switches::kWhitelistedExtensionID)
  ));
  return whitelisted_extension_id;


  CR_DEFINE_STATIC_LOCAL(const std::string,...

if that works (but it might not)

[jackhou1, 2015/03/31 04:37:45]

Done.

+    whitelisted_extension_id_ = new std::string(
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            switches::kWhitelistedExtensionID));
+  }
+  return *whitelisted_extension_id_;
+}
+
 }  // namespace extensions