Remove uses of ENABLE_CONFIGURATION_POLICY from src/chrome.

chrome/browser/extensions/api/storage/settings_apitest.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 <utility>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
+#include "chrome/browser/policy/schema_registry_service.h"
+#include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
+#include "components/policy/core/common/mock_configuration_policy_provider.h"
+#include "components/policy/core/common/policy_bundle.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_namespace.h"
+#include "components/policy/core/common/policy_types.h"
+#include "components/policy/core/common/schema.h"
+#include "components/policy/core/common/schema_map.h"
+#include "components/policy/core/common/schema_registry.h"
 #include "extensions/browser/api/storage/settings_namespace.h"
 #include "extensions/browser/api/storage/storage_frontend.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/value_builder.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/api/syncable_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
-#if defined(ENABLE_CONFIGURATION_POLICY)
-#include "chrome/browser/policy/schema_registry_service.h"
-#include "chrome/browser/policy/schema_registry_service_factory.h"
-#include "components/policy/core/browser/browser_policy_connector.h"
-#include "components/policy/core/common/mock_configuration_policy_provider.h"
-#include "components/policy/core/common/policy_bundle.h"
-#include "components/policy/core/common/policy_map.h"
-#include "components/policy/core/common/policy_namespace.h"
-#include "components/policy/core/common/policy_types.h"
-#include "components/policy/core/common/schema.h"
-#include "components/policy/core/common/schema_map.h"
-#include "components/policy/core/common/schema_registry.h"
-#endif
-
 namespace extensions {
 
 using settings_namespace::LOCAL;
 using settings_namespace::MANAGED;
 using settings_namespace::Namespace;
 using settings_namespace::SYNC;
 using settings_namespace::ToString;
 using testing::Mock;
 using testing::Return;
 using testing::_;
@@ skipping 16 matching lines @@
   MOCK_METHOD1(OnSchemaRegistryUpdated, void(bool));
 };
 
 }  // namespace
 
 class ExtensionSettingsApiTest : public ExtensionApiTest {
  protected:
   void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
 
-#if defined(ENABLE_CONFIGURATION_POLICY)
     EXPECT_CALL(policy_provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     policy_provider_.SetAutoRefresh();
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
         &policy_provider_);
-#endif
   }
 
   void ReplyWhenSatisfied(
       Namespace settings_namespace,
       const std::string& normal_action,
       const std::string& incognito_action) {
     MaybeLoadAndReplyWhenSatisfied(
         settings_namespace, normal_action, incognito_action, NULL, false);
   }
 
@@ skipping 26 matching lines @@
   void InitSync(syncer::SyncChangeProcessor* sync_processor) {
     base::MessageLoop::current()->RunUntilIdle();
     InitSyncWithSyncableService(sync_processor, GetSyncableService());
   }
 
   void SendChanges(const syncer::SyncChangeList& change_list) {
     base::MessageLoop::current()->RunUntilIdle();
     SendChangesToSyncableService(change_list, GetSyncableService());
   }
 
-#if defined(ENABLE_CONFIGURATION_POLICY)
   void SetPolicies(const base::DictionaryValue& policies) {
     scoped_ptr<policy::PolicyBundle> bundle(new policy::PolicyBundle());
     policy::PolicyMap& policy_map = bundle->Get(policy::PolicyNamespace(
         policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId));
     policy_map.LoadFrom(&policies, policy::POLICY_LEVEL_MANDATORY,
                         policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD);
     policy_provider_.UpdatePolicy(std::move(bundle));
   }
-#endif
 
  private:
   const Extension* MaybeLoadAndReplyWhenSatisfied(
       Namespace settings_namespace,
       const std::string& normal_action,
       const std::string& incognito_action,
       // May be NULL to imply not loading the extension.
       const std::string* extension_dir,
       bool is_final_action) {
     ExtensionTestMessageListener listener("waiting", true);
@@ skipping 48 matching lines @@
   }
 
   void SendChangesToSyncableService(
       const syncer::SyncChangeList& change_list,
       syncer::SyncableService* settings_service) {
     EXPECT_FALSE(
         settings_service->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
   }
 
  protected:
-#if defined(ENABLE_CONFIGURATION_POLICY)
   policy::MockConfigurationPolicyProvider policy_provider_;
-#endif
 };
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SimpleTest) {
   ASSERT_TRUE(RunExtensionTest("settings/simple_test")) << message_;
 }
 
 // Structure of this test taken from IncognitoSplitMode.
 // Note that only split-mode incognito is tested, because spanning mode
 // incognito looks the same as normal mode when the only API activity comes
 // from background pages.
@@ skipping 176 matching lines @@
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, IsStorageEnabled) {
   StorageFrontend* frontend = StorageFrontend::Get(browser()->profile());
   EXPECT_TRUE(frontend->IsStorageEnabled(LOCAL));
   EXPECT_TRUE(frontend->IsStorageEnabled(SYNC));
 
-#if defined(ENABLE_CONFIGURATION_POLICY)
   EXPECT_TRUE(frontend->IsStorageEnabled(MANAGED));
-#else
-  EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
-#endif
 }
 
-#if defined(ENABLE_CONFIGURATION_POLICY)
-
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ExtensionsSchemas) {
   // Verifies that the Schemas for the extensions domain are created on startup.
   Profile* profile = browser()->profile();
   ExtensionSystem* extension_system = ExtensionSystem::Get(profile);
   if (!extension_system->ready().is_signaled()) {
     // Wait until the extension system is ready.
     base::RunLoop run_loop;
     extension_system->ready().Post(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
     ASSERT_TRUE(extension_system->ready().is_signaled());
@@ skipping 137 matching lines @@
   // Verify that the test extension is still installed.
   const Extension* extension = GetSingleLoadedExtension();
   ASSERT_TRUE(extension);
   EXPECT_EQ(kManagedStorageExtensionId, extension->id());
 
   // Running the test again skips the onInstalled callback, and just triggers
   // the onChanged notification.
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
-#endif  // defined(ENABLE_CONFIGURATION_POLICY)
-
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ManagedStorageDisabled) {
-  // Disable the 'managed' namespace. This is redundant when
-  // ENABLE_CONFIGURATION_POLICY is not defined.
+  // Disable the 'managed' namespace.
   StorageFrontend* frontend = StorageFrontend::Get(browser()->profile());
   frontend->DisableStorageForTesting(MANAGED);
   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
   // Now run the extension.
   ASSERT_TRUE(RunExtensionTest("settings/managed_storage_disabled"))
       << message_;
 }
 
 }  // namespace extensions