extensions: Use stl utilities from the base namespace

extensions/common/features/simple_feature_unittest.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 <stddef.h>
 
 #include <string>
 
@@ skipping 530 matching lines @@
 
 TEST_F(SimpleFeatureTest, ParseWhitelist) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   base::ListValue* whitelist = new base::ListValue();
   whitelist->AppendString("foo");
   whitelist->AppendString("bar");
   value->Set("whitelist", whitelist);
   std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(2u, feature->whitelist().size());
-  EXPECT_TRUE(STLCount(feature->whitelist(), "foo"));
-  EXPECT_TRUE(STLCount(feature->whitelist(), "bar"));
+  EXPECT_TRUE(base::STLCount(feature->whitelist(), "foo"));
+  EXPECT_TRUE(base::STLCount(feature->whitelist(), "bar"));
 }
 
 TEST_F(SimpleFeatureTest, ParsePackageTypes) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   base::ListValue* extension_types = new base::ListValue();
   extension_types->AppendString("extension");
   extension_types->AppendString("theme");
   extension_types->AppendString("legacy_packaged_app");
   extension_types->AppendString("hosted_app");
   extension_types->AppendString("platform_app");
   extension_types->AppendString("shared_module");
   value->Set("extension_types", extension_types);
   std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(6u, feature->extension_types().size());
-  EXPECT_TRUE(STLCount(feature->extension_types(), Manifest::TYPE_EXTENSION));
-  EXPECT_TRUE(STLCount(feature->extension_types(), Manifest::TYPE_THEME));
   EXPECT_TRUE(
-      STLCount(feature->extension_types(), Manifest::TYPE_LEGACY_PACKAGED_APP));
-  EXPECT_TRUE(STLCount(feature->extension_types(), Manifest::TYPE_HOSTED_APP));
+      base::STLCount(feature->extension_types(), Manifest::TYPE_EXTENSION));
+  EXPECT_TRUE(base::STLCount(feature->extension_types(), Manifest::TYPE_THEME));
+  EXPECT_TRUE(base::STLCount(feature->extension_types(),
+                             Manifest::TYPE_LEGACY_PACKAGED_APP));
   EXPECT_TRUE(
-      STLCount(feature->extension_types(), Manifest::TYPE_PLATFORM_APP));
+      base::STLCount(feature->extension_types(), Manifest::TYPE_HOSTED_APP));
   EXPECT_TRUE(
-      STLCount(feature->extension_types(), Manifest::TYPE_SHARED_MODULE));
+      base::STLCount(feature->extension_types(), Manifest::TYPE_PLATFORM_APP));
+  EXPECT_TRUE(
+      base::STLCount(feature->extension_types(), Manifest::TYPE_SHARED_MODULE));
 
   value->SetString("extension_types", "all");
   std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(feature->extension_types(), feature2->extension_types());
 }
 
 TEST_F(SimpleFeatureTest, ParseContexts) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   base::ListValue* contexts = new base::ListValue();
   contexts->AppendString("blessed_extension");
   contexts->AppendString("unblessed_extension");
   contexts->AppendString("content_script");
   contexts->AppendString("web_page");
   contexts->AppendString("blessed_web_page");
   contexts->AppendString("webui");
   contexts->AppendString("extension_service_worker");
   value->Set("contexts", contexts);
   std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(7u, feature->contexts().size());
   EXPECT_TRUE(
-      STLCount(feature->contexts(), Feature::BLESSED_EXTENSION_CONTEXT));
+      base::STLCount(feature->contexts(), Feature::BLESSED_EXTENSION_CONTEXT));
+  EXPECT_TRUE(base::STLCount(feature->contexts(),
+                             Feature::UNBLESSED_EXTENSION_CONTEXT));
   EXPECT_TRUE(
-      STLCount(feature->contexts(), Feature::UNBLESSED_EXTENSION_CONTEXT));
-  EXPECT_TRUE(STLCount(feature->contexts(), Feature::CONTENT_SCRIPT_CONTEXT));
-  EXPECT_TRUE(STLCount(feature->contexts(), Feature::WEB_PAGE_CONTEXT));
-  EXPECT_TRUE(STLCount(feature->contexts(), Feature::BLESSED_WEB_PAGE_CONTEXT));
+      base::STLCount(feature->contexts(), Feature::CONTENT_SCRIPT_CONTEXT));
+  EXPECT_TRUE(base::STLCount(feature->contexts(), Feature::WEB_PAGE_CONTEXT));
+  EXPECT_TRUE(
+      base::STLCount(feature->contexts(), Feature::BLESSED_WEB_PAGE_CONTEXT));
 
   value->SetString("contexts", "all");
   std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(feature->contexts(), feature2->contexts());
 }
 
 TEST_F(SimpleFeatureTest, ParseLocation) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString("location", "component");
@@ skipping 53 matching lines @@
   feature.set_min_manifest_version(1);
   feature.set_max_manifest_version(2);
 
   // Test additive parsing. Parsing an empty dictionary should result in no
   // changes to a SimpleFeature.
   base::DictionaryValue definition;
   feature.Parse(&definition);
   EXPECT_EQ(1u, feature.whitelist().size());
   EXPECT_EQ(1u, feature.extension_types().size());
   EXPECT_EQ(1u, feature.contexts().size());
-  EXPECT_EQ(1, STLCount(feature.whitelist(), "foo"));
+  EXPECT_EQ(1, base::STLCount(feature.whitelist(), "foo"));
   EXPECT_EQ(SimpleFeature::COMPONENT_LOCATION, feature.location());
   EXPECT_EQ(1u, feature.platforms().size());
-  EXPECT_EQ(1, STLCount(feature.platforms(), Feature::CHROMEOS_PLATFORM));
+  EXPECT_EQ(1, base::STLCount(feature.platforms(), Feature::CHROMEOS_PLATFORM));
   EXPECT_EQ(1, feature.min_manifest_version());
   EXPECT_EQ(2, feature.max_manifest_version());
 
   base::ListValue* whitelist = new base::ListValue();
   base::ListValue* extension_types = new base::ListValue();
   base::ListValue* contexts = new base::ListValue();
   whitelist->AppendString("bar");
   extension_types->AppendString("extension");
   contexts->AppendString("unblessed_extension");
   definition.Set("whitelist", whitelist);
   definition.Set("extension_types", extension_types);
   definition.Set("contexts", contexts);
   // Can't test location or platform because we only have one value so far.
   definition.Set("min_manifest_version", new base::FundamentalValue(2));
   definition.Set("max_manifest_version", new base::FundamentalValue(3));
 
   feature.Parse(&definition);
   EXPECT_EQ(1u, feature.whitelist().size());
   EXPECT_EQ(1u, feature.extension_types().size());
   EXPECT_EQ(1u, feature.contexts().size());
-  EXPECT_EQ(1, STLCount(feature.whitelist(), "bar"));
-  EXPECT_EQ(1, STLCount(feature.extension_types(), Manifest::TYPE_EXTENSION));
-  EXPECT_EQ(1,
-            STLCount(feature.contexts(), Feature::UNBLESSED_EXTENSION_CONTEXT));
+  EXPECT_EQ(1, base::STLCount(feature.whitelist(), "bar"));
+  EXPECT_EQ(
+      1, base::STLCount(feature.extension_types(), Manifest::TYPE_EXTENSION));
+  EXPECT_EQ(1, base::STLCount(feature.contexts(),
+                              Feature::UNBLESSED_EXTENSION_CONTEXT));
   EXPECT_EQ(2, feature.min_manifest_version());
   EXPECT_EQ(3, feature.max_manifest_version());
 }
 
 TEST_F(SimpleFeatureTest, CommandLineSwitch) {
   SimpleFeature feature;
   feature.set_command_line_switch("laser-beams");
   {
     EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
               feature.IsAvailableToEnvironment().result());
@@ skipping 249 matching lines @@
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
   }
 }
 
 }  // namespace extensions