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 49 matching lines @@
   }
   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();
+    CHECK(channel_.get());
+    return *channel_;
   }
 
-  void SetChannelForTesting(VersionInfo::Channel channel_for_testing) {
-    channel_for_testing_.reset(new VersionInfo::Channel(channel_for_testing));
+  bool HasChannel() {
+    return channel_.get();
   }
 
-  void ResetChannelForTesting() {
-    channel_for_testing_.reset();
+  void SetChannel(VersionInfo::Channel channel) {
+    channel_.reset(new VersionInfo::Channel(channel));
+  }
+
+  void ClearChannel() {
+    channel_.reset();
   }
 
  private:
-  scoped_ptr<VersionInfo::Channel> channel_for_testing_;
+  scoped_ptr<VersionInfo::Channel> channel_;
 };
 
 static base::LazyInstance<Channel> g_channel = LAZY_INSTANCE_INITIALIZER;
 
 // 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;
@@ skipping 217 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 (g_channel.Get().HasChannel()) {
     if (channel_ < g_channel.Get().GetChannel())
       return UNSUPPORTED_CHANNEL;
+  } else {
+    // Would warn here, but it'd be very spammy in tests.
   }
 
   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();
+bool Feature::HasCurrentChannel() {
+  return g_channel.Get().HasChannel();
 }
 
 // static
 chrome::VersionInfo::Channel Feature::GetCurrentChannel() {
-  if (g_channel_checking_enabled)
-    return g_channel.Get().GetChannel();
-  return chrome::VersionInfo::GetChannel();
+  CHECK(g_channel.Get().HasChannel()) << "No channel has been set.";
+  return g_channel.Get().GetChannel();
+}
+
+// static
+void Feature::SetCurrentChannel(VersionInfo::Channel channel) {
+  g_channel.Get().SetChannel(channel);
+}
+
+// static
+void Feature::ClearCurrentChannel() {
+  g_channel.Get().ClearChannel();
 }
 
 }  // namespace