Move enable extensions define to a build flag.

chrome/browser/policy/managed_bookmarks_policy_handler_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 "chrome/browser/policy/managed_bookmarks_policy_handler.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
 #include "components/policy/core/browser/configuration_policy_pref_store.h"
 #include "components/policy/core/browser/configuration_policy_pref_store_test.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/policy_constants.h"
+#include "extensions/features/features.h"
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "extensions/common/value_builder.h"
 #endif
 
 namespace policy {
 
 class ManagedBookmarksPolicyHandlerTest
     : public ConfigurationPolicyPrefStoreTest {
   void SetUp() override {
     Schema chrome_schema = Schema::Wrap(GetChromeSchemaData());
     handler_list_.AddHandler(base::WrapUnique<ConfigurationPolicyHandler>(
         new ManagedBookmarksPolicyHandler(chrome_schema)));
   }
 };
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 TEST_F(ManagedBookmarksPolicyHandlerTest, ApplyPolicySettings) {
   EXPECT_FALSE(store_->GetValue(bookmarks::prefs::kManagedBookmarks, NULL));
 
   PolicyMap policy;
   policy.Set(key::kManagedBookmarks, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
              base::JSONReader::Read("["
                                     // The following gets filtered out from the
                                     // JSON string when parsed.
                                     "  {"
@@ skipping 83 matching lines @@
                                                          "com"
                                                          "/")
                                                     .Build())
                                             .Build())
                                    .Build())
                            .Build())
                   .Build())
           .Build());
   EXPECT_TRUE(pref_value->Equals(expected.get()));
 }
-#endif  // defined(ENABLE_EXTENSIONS)
+#endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 TEST_F(ManagedBookmarksPolicyHandlerTest, ApplyPolicySettingsNoTitle) {
   EXPECT_FALSE(store_->GetValue(bookmarks::prefs::kManagedBookmarks, NULL));
 
   PolicyMap policy;
   policy.Set(key::kManagedBookmarks, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
              base::JSONReader::Read("["
                                     "  {"
                                     "    \"name\": \"Google\","
                                     "    \"url\": \"google.com\""
@@ skipping 17 matching lines @@
 
   std::unique_ptr<base::Value> expected(
       extensions::ListBuilder()
           .Append(extensions::DictionaryBuilder()
                       .Set("name", "Google")
                       .Set("url", "http://google.com/")
                       .Build())
           .Build());
   EXPECT_TRUE(pref_value->Equals(expected.get()));
 }
-#endif  // defined(ENABLE_EXTENSIONS)
+#endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
 TEST_F(ManagedBookmarksPolicyHandlerTest, WrongPolicyType) {
   PolicyMap policy;
   // The expected type is base::ListValue, but this policy sets it as an
   // unparsed base::StringValue. Any type other than ListValue should fail.
   policy.Set(key::kManagedBookmarks, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
              base::MakeUnique<base::StringValue>("["
                                                  "  {"
                                                  "    \"name\": \"Google\","
                                                  "    \"url\": \"google.com\""
                                                  "  },"
                                                  "]"),
              nullptr);
   UpdateProviderPolicy(policy);
   EXPECT_FALSE(store_->GetValue(bookmarks::prefs::kManagedBookmarks, NULL));
 }
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 TEST_F(ManagedBookmarksPolicyHandlerTest, UnknownKeys) {
   PolicyMap policy;
   policy.Set(key::kManagedBookmarks, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
              base::JSONReader::Read("["
                                     "  {"
                                     "    \"name\": \"Google\","
                                     "    \"unknown\": \"should be ignored\","
                                     "    \"url\": \"google.com\""
                                     "  }"
                                     "]"),
              nullptr);
   UpdateProviderPolicy(policy);
   const base::Value* pref_value = NULL;
   EXPECT_TRUE(
       store_->GetValue(bookmarks::prefs::kManagedBookmarks, &pref_value));
   ASSERT_TRUE(pref_value);
 
   std::unique_ptr<base::Value> expected(
       extensions::ListBuilder()
           .Append(extensions::DictionaryBuilder()
                       .Set("name", "Google")
                       .Set("url", "http://google.com/")
                       .Build())
           .Build());
   EXPECT_TRUE(pref_value->Equals(expected.get()));
 }
 #endif
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 TEST_F(ManagedBookmarksPolicyHandlerTest, BadBookmark) {
   PolicyMap policy;
   policy.Set(key::kManagedBookmarks, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
              base::JSONReader::Read("["
                                     "  {"
                                     "    \"name\": \"Empty\","
                                     "    \"url\": \"\""
                                     "  },"
                                     "  {"
@@ skipping 21 matching lines @@
           .Append(extensions::DictionaryBuilder()
                       .Set("name", "Google")
                       .Set("url", "http://google.com/")
                       .Build())
           .Build());
   EXPECT_TRUE(pref_value->Equals(expected.get()));
 }
 #endif
 
 }  // namespace policy