Properly propagate the current Chrome channel into the Feature system on the

chrome/common/extensions/features/feature.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/features/feature.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 31 matching lines @@
     channels["stable"] = VersionInfo::CHANNEL_STABLE;
   }
 
   std::map<std::string, Extension::Type> extension_types;
   std::map<std::string, extensions::Feature::Context> contexts;
   std::map<std::string, extensions::Feature::Location> locations;
   std::map<std::string, extensions::Feature::Platform> platforms;
   std::map<std::string, VersionInfo::Channel> channels;
 };
 
-static base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
 
 std::string GetChannelName(VersionInfo::Channel channel) {
   typedef std::map<std::string, VersionInfo::Channel> ChannelsMap;
   ChannelsMap channels = g_mappings.Get().channels;
   for (ChannelsMap::iterator i = channels.begin(); i != channels.end(); ++i) {
     if (i->second == channel)
       return i->first;
   }
   NOTREACHED();
   return "unknown";
 }
 
-static bool g_channel_checking_enabled = false;
-
-class Channel {
- public:
-  VersionInfo::Channel GetChannel() {
-    CHECK(g_channel_checking_enabled);
-    if (channel_for_testing_.get())
-      return *channel_for_testing_;
-    return VersionInfo::GetChannel();
-  }
-
-  void SetChannelForTesting(VersionInfo::Channel channel_for_testing) {
-    channel_for_testing_.reset(new VersionInfo::Channel(channel_for_testing));
-  }
-
-  void ResetChannelForTesting() {
-    channel_for_testing_.reset();
-  }
-
- private:
-  scoped_ptr<VersionInfo::Channel> channel_for_testing_;
-};
-
-static base::LazyInstance<Channel> g_channel = LAZY_INSTANCE_INITIALIZER;
+VersionInfo::Channel g_current_channel = VersionInfo::CHANNEL_STABLE;
 
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
 void ParseSet(const DictionaryValue* value,
               const std::string& property,
               std::set<std::string>* set) {
   const ListValue* list_value = NULL;
   if (!value->GetList(property, &list_value))
     return;
 
@@ skipping 214 matching lines @@
 
   if (platform_ != UNSPECIFIED_PLATFORM && platform_ != platform)
     return INVALID_PLATFORM;
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return INVALID_MIN_MANIFEST_VERSION;
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return INVALID_MAX_MANIFEST_VERSION;
 
-  if (g_channel_checking_enabled) {
-    if (channel_ < g_channel.Get().GetChannel())
-      return UNSUPPORTED_CHANNEL;
-  }
+  if (channel_ < g_current_channel)
+    return UNSUPPORTED_CHANNEL;
 
   return IS_AVAILABLE;
 }
 
 Feature::Availability Feature::IsAvailableToContext(
     const Extension* extension,
     Feature::Context context,
     Feature::Platform platform) const {
   Availability result = IsAvailableToManifest(
       extension->id(),
       extension->GetType(),
       ConvertLocation(extension->location()),
       extension->manifest_version(),
       platform);
   if (result != IS_AVAILABLE)
     return result;
 
   if (!contexts_.empty() &&
       contexts_.find(context) == contexts_.end()) {
     return INVALID_CONTEXT;
   }
 
   return IS_AVAILABLE;
 }
 
 // static
-void Feature::SetChannelCheckingEnabled(bool enabled) {
-  g_channel_checking_enabled = enabled;
-}
-
-// static
-void Feature::ResetChannelCheckingEnabled() {
-  g_channel_checking_enabled = false;
-}
-
-// static
-void Feature::SetChannelForTesting(VersionInfo::Channel channel) {
-  g_channel.Get().SetChannelForTesting(channel);
-}
-
-// static
-void Feature::ResetChannelForTesting() {
-  g_channel.Get().ResetChannelForTesting();
-}
-
-// static
 chrome::VersionInfo::Channel Feature::GetCurrentChannel() {
-  if (g_channel_checking_enabled)
-    return g_channel.Get().GetChannel();
-  return chrome::VersionInfo::GetChannel();
+  return g_current_channel;
+}
+
+// static
+void Feature::SetCurrentChannel(VersionInfo::Channel channel) {
+  g_current_channel = channel;
 }
 
 }  // namespace