chrome/browser/net/chrome_network_delegate_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/net/chrome_network_delegate.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/prefs/pref_member.h"
  12 #include "chrome/browser/content_settings/cookie_settings.h"
  13 #include "chrome/browser/net/safe_search_util.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "chrome/test/base/testing_pref_service_syncable.h"
  16 #include "chrome/test/base/testing_profile.h"
  17 #include "content/public/common/content_switches.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "net/base/request_priority.h"
  20 #include "net/url_request/url_request.h"
  21 #include "net/url_request/url_request_test_util.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 #if defined(ENABLE_EXTENSIONS)
  25 #include "chrome/browser/extensions/event_router_forwarder.h"
  26 #endif
  27
  28 TEST(ChromeNetworkDelegateTest, DisableFirstPartyOnlyCookiesIffFlagDisabled) {
  29   BooleanPrefMember pref_member_;
  30   scoped_ptr<ChromeNetworkDelegate> delegate;
  31
  32 #if defined(ENABLE_EXTENSIONS)
  33   scoped_refptr<extensions::EventRouterForwarder> forwarder =
  34       new extensions::EventRouterForwarder();
  35   delegate.reset(new ChromeNetworkDelegate(forwarder.get(), &pref_member_));
  36 #else
  37   delegate.reset(new ChromeNetworkDelegate(nullptr, &pref_member_));
  38 #endif
  39   EXPECT_FALSE(delegate->FirstPartyOnlyCookieExperimentEnabled());
  40 }
  41
  42 TEST(ChromeNetworkDelegateTest, EnableFirstPartyOnlyCookiesIffFlagEnabled) {
  43   base::CommandLine::ForCurrentProcess()->AppendSwitch(
  44       switches::kEnableExperimentalWebPlatformFeatures);
  45   BooleanPrefMember pref_member_;
  46   scoped_ptr<ChromeNetworkDelegate> delegate;
  47
  48 #if defined(ENABLE_EXTENSIONS)
  49   scoped_refptr<extensions::EventRouterForwarder> forwarder =
  50       new extensions::EventRouterForwarder();
  51   delegate.reset(new ChromeNetworkDelegate(forwarder.get(), &pref_member_));
  52 #else
  53   delegate.reset(new ChromeNetworkDelegate(nullptr, &pref_member_));
  54 #endif
  55   EXPECT_TRUE(delegate->FirstPartyOnlyCookieExperimentEnabled());
  56 }
  57
  58 #if defined(ENABLE_EXTENSIONS)
  59 class ChromeNetworkDelegateThrottlingTest : public testing::Test {
  60  protected:
  61   ChromeNetworkDelegateThrottlingTest()
  62       : forwarder_(new extensions::EventRouterForwarder()) {}
  63
  64   void SetUp() override {
  65     never_throttle_requests_original_value_ =
  66         ChromeNetworkDelegate::g_never_throttle_requests_;
  67     ChromeNetworkDelegate::g_never_throttle_requests_ = false;
  68   }
  69
  70   void TearDown() override {
  71     ChromeNetworkDelegate::g_never_throttle_requests_ =
  72         never_throttle_requests_original_value_;
  73   }
  74
  75   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
  76     return make_scoped_ptr(
  77         new ChromeNetworkDelegate(forwarder(), &pref_member_));
  78   }
  79
  80   // Implementation moved here for access to private bits.
  81   void NeverThrottleLogicImpl() {
  82     scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
  83
  84     net::TestURLRequestContext context;
  85     scoped_ptr<net::URLRequest> extension_request(context.CreateRequest(
  86         GURL("http://example.com/"), net::DEFAULT_PRIORITY, NULL));
  87     extension_request->set_first_party_for_cookies(
  88         GURL("chrome-extension://abcdef/bingo.html"));
  89     scoped_ptr<net::URLRequest> web_page_request(context.CreateRequest(
  90         GURL("http://example.com/"), net::DEFAULT_PRIORITY, NULL));
  91     web_page_request->set_first_party_for_cookies(
  92         GURL("http://example.com/helloworld.html"));
  93
  94     ASSERT_TRUE(delegate->OnCanThrottleRequest(*extension_request));
  95     ASSERT_FALSE(delegate->OnCanThrottleRequest(*web_page_request));
  96
  97     delegate->NeverThrottleRequests();
  98     ASSERT_TRUE(ChromeNetworkDelegate::g_never_throttle_requests_);
  99     ASSERT_FALSE(delegate->OnCanThrottleRequest(*extension_request));
 100     ASSERT_FALSE(delegate->OnCanThrottleRequest(*web_page_request));
 101
 102     // Verify that the flag applies to later instances of the
 103     // ChromeNetworkDelegate.
 104     //
 105     // We test the side effects of the flag rather than just the flag
 106     // itself (which we did above) to help ensure that a changed
 107     // implementation would show the same behavior, i.e. all instances
 108     // of ChromeNetworkDelegate after the flag is set obey the flag.
 109     scoped_ptr<ChromeNetworkDelegate> second_delegate(CreateNetworkDelegate());
 110     ASSERT_FALSE(delegate->OnCanThrottleRequest(*extension_request));
 111     ASSERT_FALSE(delegate->OnCanThrottleRequest(*web_page_request));
 112   }
 113
 114  private:
 115   extensions::EventRouterForwarder* forwarder() { return forwarder_.get(); }
 116
 117   bool never_throttle_requests_original_value_;
 118   base::MessageLoopForIO message_loop_;
 119
 120   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 121   BooleanPrefMember pref_member_;
 122 };
 123
 124 TEST_F(ChromeNetworkDelegateThrottlingTest, NeverThrottleLogic) {
 125   NeverThrottleLogicImpl();
 126 }
 127 #endif  // defined(ENABLE_EXTENSIONS)
 128
 129 class ChromeNetworkDelegateSafeSearchTest : public testing::Test {
 130  public:
 131   ChromeNetworkDelegateSafeSearchTest()
 132       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 133 #if defined(ENABLE_EXTENSIONS)
 134     forwarder_ = new extensions::EventRouterForwarder();
 135 #endif
 136   }
 137
 138   void SetUp() override {
 139     ChromeNetworkDelegate::InitializePrefsOnUIThread(
 140         &enable_referrers_,
 141         NULL,
 142         &force_safe_search_,
 143         &force_google_safe_search_,
 144         &force_youtube_safety_mode_,
 145         profile_.GetTestingPrefService());
 146   }
 147
 148  protected:
 149   scoped_ptr<net::NetworkDelegate> CreateNetworkDelegate() {
 150     scoped_ptr<ChromeNetworkDelegate> network_delegate(
 151         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
 152     network_delegate->set_force_safe_search(&force_safe_search_);
 153     network_delegate->set_force_google_safe_search(&force_google_safe_search_);
 154     network_delegate->set_force_youtube_safety_mode(
 155         &force_youtube_safety_mode_);
 156     return network_delegate.Pass();
 157   }
 158
 159   void SetSafeSearch(bool safe_search,
 160                      bool google_safe_search,
 161                      bool youtube_safety_mode) {
 162     force_safe_search_.SetValue(safe_search);
 163     force_google_safe_search_.SetValue(google_safe_search);
 164     force_youtube_safety_mode_.SetValue(youtube_safety_mode);
 165   }
 166
 167   void SetDelegate(net::NetworkDelegate* delegate) {
 168     network_delegate_ = delegate;
 169     context_.set_network_delegate(network_delegate_);
 170   }
 171
 172   // Does a request to an arbitrary URL and verifies that the SafeSearch
 173   // enforcement utility functions were called/not called as expected.
 174   void QueryURL(bool expect_google_safe_search,
 175                 bool expect_youtube_safety_mode) {
 176     safe_search_util::ClearForceGoogleSafeSearchCountForTesting();
 177     safe_search_util::ClearForceYouTubeSafetyModeCountForTesting();
 178
 179     scoped_ptr<net::URLRequest> request(context_.CreateRequest(
 180         GURL("http://anyurl.com"), net::DEFAULT_PRIORITY, &delegate_));
 181
 182     request->Start();
 183     base::MessageLoop::current()->RunUntilIdle();
 184
 185     EXPECT_EQ(expect_google_safe_search ? 1 : 0,
 186         safe_search_util::GetForceGoogleSafeSearchCountForTesting());
 187     EXPECT_EQ(expect_youtube_safety_mode ? 1 : 0,
 188         safe_search_util::GetForceYouTubeSafetyModeCountForTesting());
 189   }
 190
 191  private:
 192   extensions::EventRouterForwarder* forwarder() {
 193 #if defined(ENABLE_EXTENSIONS)
 194     return forwarder_.get();
 195 #else
 196     return NULL;
 197 #endif
 198   }
 199
 200   content::TestBrowserThreadBundle thread_bundle_;
 201 #if defined(ENABLE_EXTENSIONS)
 202   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 203 #endif
 204   TestingProfile profile_;
 205   BooleanPrefMember enable_referrers_;
 206   BooleanPrefMember force_safe_search_;
 207   BooleanPrefMember force_google_safe_search_;
 208   BooleanPrefMember force_youtube_safety_mode_;
 209   scoped_ptr<net::URLRequest> request_;
 210   net::TestURLRequestContext context_;
 211   net::NetworkDelegate* network_delegate_;
 212   net::TestDelegate delegate_;
 213 };
 214
 215 TEST_F(ChromeNetworkDelegateSafeSearchTest, SafeSearch) {
 216   scoped_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
 217   SetDelegate(delegate.get());
 218
 219   // Loop over all combinations of the three policies.
 220   for (int i = 0; i < 8; i++) {
 221     bool safe_search = i % 2;
 222     bool google_safe_search = (i / 2) % 2;
 223     bool youtube_safety_mode = i / 4;
 224     SetSafeSearch(safe_search, google_safe_search, youtube_safety_mode);
 225
 226     // The old "SafeSearch" policy implies both Google and YouTube.
 227     bool expect_google_safe_search = safe_search || google_safe_search;
 228     bool expect_youtube_safety_mode = safe_search || youtube_safety_mode;
 229     QueryURL(expect_google_safe_search, expect_youtube_safety_mode);
 230   }
 231 }
 232
 233 // Privacy Mode disables Channel Id if cookies are blocked (cr223191)
 234 class ChromeNetworkDelegatePrivacyModeTest : public testing::Test {
 235  public:
 236   ChromeNetworkDelegatePrivacyModeTest()
 237       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
 238 #if defined(ENABLE_EXTENSIONS)
 239         forwarder_(new extensions::EventRouterForwarder()),
 240 #endif
 241         cookie_settings_(CookieSettings::Factory::GetForProfile(&profile_)
 242                              .get()),
 243         kBlockedSite("http://ads.thirdparty.com"),
 244         kAllowedSite("http://good.allays.com"),
 245         kFirstPartySite("http://cool.things.com"),
 246         kBlockedFirstPartySite("http://no.thirdparties.com") {}
 247
 248   void SetUp() override {
 249     ChromeNetworkDelegate::InitializePrefsOnUIThread(
 250         &enable_referrers_, NULL, NULL, NULL, NULL,
 251         profile_.GetTestingPrefService());
 252   }
 253
 254  protected:
 255   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
 256     scoped_ptr<ChromeNetworkDelegate> network_delegate(
 257         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
 258     network_delegate->set_cookie_settings(cookie_settings_);
 259     return network_delegate.Pass();
 260   }
 261
 262   void SetDelegate(net::NetworkDelegate* delegate) {
 263     network_delegate_ = delegate;
 264     context_.set_network_delegate(network_delegate_);
 265   }
 266
 267  protected:
 268   extensions::EventRouterForwarder* forwarder() {
 269 #if defined(ENABLE_EXTENSIONS)
 270     return forwarder_.get();
 271 #else
 272     return NULL;
 273 #endif
 274   }
 275
 276   content::TestBrowserThreadBundle thread_bundle_;
 277 #if defined(ENABLE_EXTENSIONS)
 278   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 279 #endif
 280   TestingProfile profile_;
 281   CookieSettings* cookie_settings_;
 282   BooleanPrefMember enable_referrers_;
 283   scoped_ptr<net::URLRequest> request_;
 284   net::TestURLRequestContext context_;
 285   net::NetworkDelegate* network_delegate_;
 286
 287   const GURL kBlockedSite;
 288   const GURL kAllowedSite;
 289   const GURL kEmptyFirstPartySite;
 290   const GURL kFirstPartySite;
 291   const GURL kBlockedFirstPartySite;
 292 };
 293
 294 TEST_F(ChromeNetworkDelegatePrivacyModeTest, DisablePrivacyIfCookiesAllowed) {
 295   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 296   SetDelegate(delegate.get());
 297
 298   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 299                                                        kEmptyFirstPartySite));
 300 }
 301
 302
 303 TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfCookiesBlocked) {
 304   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 305   SetDelegate(delegate.get());
 306
 307   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
 308                                                        kEmptyFirstPartySite));
 309
 310   cookie_settings_->SetCookieSetting(
 311       ContentSettingsPattern::FromURL(kBlockedSite),
 312       ContentSettingsPattern::Wildcard(),
 313       CONTENT_SETTING_BLOCK);
 314   EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
 315                                                       kEmptyFirstPartySite));
 316 }
 317
 318 TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfThirdPartyBlocked) {
 319   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 320   SetDelegate(delegate.get());
 321
 322   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 323                                                        kFirstPartySite));
 324
 325   profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
 326   EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 327                                                       kFirstPartySite));
 328   profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, false);
 329   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 330                                                        kFirstPartySite));
 331 }
 332
 333 TEST_F(ChromeNetworkDelegatePrivacyModeTest,
 334        DisablePrivacyIfOnlyFirstPartyBlocked) {
 335   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 336   SetDelegate(delegate.get());
 337
 338   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 339                                                        kBlockedFirstPartySite));
 340
 341   cookie_settings_->SetCookieSetting(
 342       ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
 343       ContentSettingsPattern::Wildcard(),
 344       CONTENT_SETTING_BLOCK);
 345   // Privacy mode is disabled as kAllowedSite is still getting cookies
 346   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 347                                                        kBlockedFirstPartySite));
 348 }