Move enable extensions define to a build flag.

chrome/browser/net/chrome_network_delegate_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/browser/net/chrome_network_delegate.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 17 matching lines @@
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/data_usage/core/data_use_amortizer.h"
 #include "components/data_usage/core/data_use_annotator.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_member.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/features/features.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_request_headers.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
 namespace {
 
 // This function requests a URL, and makes it return a known response. If
 // |from_user| is true, it attaches a ResourceRequestInfo to the URLRequest,
 // because requests from users have this info. If |from_user| is false, the
 // request is presumed to be from a service, and the service name is set in the
 // request's user data. (As an example suggestions service tag is attached). if
@@ skipping 80 matching lines @@
   int64_t off_the_record_rx_bytes_;
 };
 
 }  // namespace
 
 class ChromeNetworkDelegateTest : public testing::Test {
  public:
   ChromeNetworkDelegateTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         context_(new net::TestURLRequestContext(true)) {
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
   }
 
   void SetUp() override {
     ChromeNetworkDelegate::InitializePrefsOnUIThread(
         &enable_referrers_, nullptr, nullptr, nullptr, nullptr,
         profile_.GetTestingPrefService());
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
@@ skipping 11 matching lines @@
 
   net::TestURLRequestContext* context() { return context_.get(); }
   net::NetworkDelegate* network_delegate() { return network_delegate_.get(); }
   net::MockClientSocketFactory* socket_factory() { return &socket_factory_; }
 
   ChromeNetworkDelegate* chrome_network_delegate() {
     return network_delegate_.get();
   }
 
   extensions::EventRouterForwarder* forwarder() {
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
     return forwarder_.get();
 #else
     return nullptr;
 #endif
   }
 
  private:
   std::unique_ptr<TestingProfileManager> profile_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 #endif
   TestingProfile profile_;
   BooleanPrefMember enable_referrers_;
   std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
   net::MockClientSocketFactory socket_factory_;
   std::unique_ptr<net::TestURLRequestContext> context_;
 };
 
 // Test that the total data use consumed by Chrome is recorded correctly.
@@ skipping 158 matching lines @@
   EXPECT_EQ(request->GetTotalSentBytes(),
             fake_aggregator.off_the_record_tx_bytes());
   EXPECT_EQ(request->GetTotalReceivedBytes(),
             fake_aggregator.off_the_record_rx_bytes());
 }
 
 class ChromeNetworkDelegatePolicyTest : public testing::Test {
  public:
   ChromeNetworkDelegatePolicyTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
   }
 
  protected:
    void SetDelegate(net::NetworkDelegate* delegate) {
      context_.set_network_delegate(delegate);
    }
 
   extensions::EventRouterForwarder* forwarder() {
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
     return forwarder_.get();
 #else
     return nullptr;
 #endif
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 #endif
   TestingProfile profile_;
   BooleanPrefMember enable_referrers_;
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
   DISALLOW_COPY_AND_ASSIGN(ChromeNetworkDelegatePolicyTest);
 };
 
 class ChromeNetworkDelegateSafeSearchTest :
@@ skipping 153 matching lines @@
   std::unique_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
   SetDelegate(delegate.get());
   CheckAllowedDomainsHeaders("google.com", GURL("http://example.com"), false);
 }
 
 // Privacy Mode disables Channel Id if cookies are blocked (cr223191)
 class ChromeNetworkDelegatePrivacyModeTest : public testing::Test {
  public:
   ChromeNetworkDelegatePrivacyModeTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
         forwarder_(new extensions::EventRouterForwarder()),
 #endif
         cookie_settings_(CookieSettingsFactory::GetForProfile(&profile_).get()),
         kBlockedSite("http://ads.thirdparty.com"),
         kAllowedSite("http://good.allays.com"),
         kFirstPartySite("http://cool.things.com"),
         kBlockedFirstPartySite("http://no.thirdparties.com") {
   }
 
   void SetUp() override {
@@ skipping 11 matching lines @@
     return network_delegate;
   }
 
   void SetDelegate(net::NetworkDelegate* delegate) {
     network_delegate_ = delegate;
     context_.set_network_delegate(network_delegate_);
   }
 
  protected:
   extensions::EventRouterForwarder* forwarder() {
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
     return forwarder_.get();
 #else
     return NULL;
 #endif
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-#if defined(ENABLE_EXTENSIONS)
+#if BUILDFLAG(ENABLE_EXTENSIONS)
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 #endif
   TestingProfile profile_;
   content_settings::CookieSettings* cookie_settings_;
   BooleanPrefMember enable_referrers_;
   std::unique_ptr<net::URLRequest> request_;
   net::TestURLRequestContext context_;
   net::NetworkDelegate* network_delegate_;
 
   const GURL kBlockedSite;
@@ skipping 46 matching lines @@
 
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 
   cookie_settings_->SetCookieSetting(kBlockedFirstPartySite,
                                      CONTENT_SETTING_BLOCK);
   // Privacy mode is disabled as kAllowedSite is still getting cookies
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 }