Rewrite std::string("") to std::string(), Linux edition.

chrome/common/extensions/features/simple_feature_unittest.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/simple_feature.h"
 
 #include "chrome/common/extensions/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using chrome::VersionInfo;
@@ skipping 73 matching lines @@
   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
       kIdFoo, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
       Feature::UNSPECIFIED_PLATFORM).result());
   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
       kIdBar, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
       Feature::UNSPECIFIED_PLATFORM).result());
 
   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
       kIdBaz, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
       Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::NOT_FOUND_IN_WHITELIST,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
       kIdBaz, Manifest::TYPE_LEGACY_PACKAGED_APP,
       Feature::UNSPECIFIED_LOCATION, -1,
       Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, HashedIdWhitelist) {
   // echo -n "fooabbbbccccddddeeeeffffgggghhhh" |
@@ skipping 19 matching lines @@
       "tooshortforanextensionid", Manifest::TYPE_UNKNOWN,
       Feature::UNSPECIFIED_LOCATION, -1,
       Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, PackageType) {
   SimpleFeature feature;
   feature.extension_types()->insert(Manifest::TYPE_EXTENSION);
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
 
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_EXTENSION, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_LEGACY_PACKAGED_APP, Feature::UNSPECIFIED_LOCATION,
-      -1, Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_EXTENSION,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_LEGACY_PACKAGED_APP,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 
-  EXPECT_EQ(Feature::INVALID_TYPE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::INVALID_TYPE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_THEME, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_TYPE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_TYPE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_THEME,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Context) {
   SimpleFeature feature;
   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
   feature.set_platform(Feature::CHROMEOS_PLATFORM);
   feature.set_min_manifest_version(21);
   feature.set_max_manifest_version(25);
 
@@ skipping 54 matching lines @@
       Feature::CHROMEOS_PLATFORM).result());
   feature.set_max_manifest_version(25);
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Location) {
   SimpleFeature feature;
 
   // If the feature specifies "component" as its location, then only component
   // extensions can access it.
   feature.set_location(Feature::COMPONENT_LOCATION);
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::COMPONENT_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::COMPONENT_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_LOCATION,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 
   // But component extensions can access anything else, whatever their location.
   feature.set_location(Feature::UNSPECIFIED_LOCATION);
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::COMPONENT_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::COMPONENT_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Platform) {
   SimpleFeature feature;
   feature.set_platform(Feature::CHROMEOS_PLATFORM);
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::CHROMEOS_PLATFORM).result());
-  EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+            feature.IsAvailableToManifest(std::string(),
+                                          Manifest::TYPE_UNKNOWN,
+                                          Feature::UNSPECIFIED_LOCATION,
+                                          -1,
+                                          Feature::CHROMEOS_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_PLATFORM,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    -1,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Version) {
   SimpleFeature feature;
   feature.set_min_manifest_version(5);
 
-  EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION,
-            feature.IsAvailableToManifest(
-                "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-                0, Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION,
-            feature.IsAvailableToManifest(
-                "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-                4, Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_MIN_MANIFEST_VERSION,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    0,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_MIN_MANIFEST_VERSION,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    4,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-      5, Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-      10, Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    5,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    10,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 
   feature.set_max_manifest_version(8);
 
-  EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION,
-            feature.IsAvailableToManifest(
-                "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-                10, Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::IS_AVAILABLE,
-            feature.IsAvailableToManifest(
-                "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-                8, Feature::UNSPECIFIED_PLATFORM).result());
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
-      "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
-      7, Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::INVALID_MAX_MANIFEST_VERSION,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    10,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    8,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature.IsAvailableToManifest(std::string(),
+                                    Manifest::TYPE_UNKNOWN,
+                                    Feature::UNSPECIFIED_LOCATION,
+                                    7,
+                                    Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseNull) {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_TRUE(feature->whitelist()->empty());
   EXPECT_TRUE(feature->extension_types()->empty());
   EXPECT_TRUE(feature->GetContexts()->empty());
   EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
@@ skipping 251 matching lines @@
       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_CANARY));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_DEV));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_BETA));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_STABLE));
 
   // Default supported channel (trunk).
   EXPECT_EQ(Feature::IS_AVAILABLE,
-      IsAvailableInChannel("", VersionInfo::CHANNEL_UNKNOWN));
+            IsAvailableInChannel(std::string(), VersionInfo::CHANNEL_UNKNOWN));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
-      IsAvailableInChannel("", VersionInfo::CHANNEL_CANARY));
+            IsAvailableInChannel(std::string(), VersionInfo::CHANNEL_CANARY));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
-      IsAvailableInChannel("", VersionInfo::CHANNEL_DEV));
+            IsAvailableInChannel(std::string(), VersionInfo::CHANNEL_DEV));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
-      IsAvailableInChannel("", VersionInfo::CHANNEL_BETA));
+            IsAvailableInChannel(std::string(), VersionInfo::CHANNEL_BETA));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
-      IsAvailableInChannel("", VersionInfo::CHANNEL_STABLE));
+            IsAvailableInChannel(std::string(), VersionInfo::CHANNEL_STABLE));
 }
 
 }  // namespace