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 class ChromeNetworkDelegateSafeSearchTest : public testing::Test {
  59  public:
  60   ChromeNetworkDelegateSafeSearchTest()
  61       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
  62 #if defined(ENABLE_EXTENSIONS)
  63     forwarder_ = new extensions::EventRouterForwarder();
  64 #endif
  65   }
  66
  67   void SetUp() override {
  68     ChromeNetworkDelegate::InitializePrefsOnUIThread(
  69         &enable_referrers_,
  70         NULL,
  71         &force_google_safe_search_,
  72         &force_youtube_safety_mode_,
  73         profile_.GetTestingPrefService());
  74   }
  75
  76  protected:
  77   scoped_ptr<net::NetworkDelegate> CreateNetworkDelegate() {
  78     scoped_ptr<ChromeNetworkDelegate> network_delegate(
  79         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
  80     network_delegate->set_force_google_safe_search(&force_google_safe_search_);
  81     network_delegate->set_force_youtube_safety_mode(
  82         &force_youtube_safety_mode_);
  83     return network_delegate.Pass();
  84   }
  85
  86   void SetSafeSearch(bool google_safe_search,
  87                      bool youtube_safety_mode) {
  88     force_google_safe_search_.SetValue(google_safe_search);
  89     force_youtube_safety_mode_.SetValue(youtube_safety_mode);
  90   }
  91
  92   void SetDelegate(net::NetworkDelegate* delegate) {
  93     network_delegate_ = delegate;
  94     context_.set_network_delegate(network_delegate_);
  95   }
  96
  97   // Does a request to an arbitrary URL and verifies that the SafeSearch
  98   // enforcement utility functions were called/not called as expected.
  99   void QueryURL(bool expect_google_safe_search,
 100                 bool expect_youtube_safety_mode) {
 101     safe_search_util::ClearForceGoogleSafeSearchCountForTesting();
 102     safe_search_util::ClearForceYouTubeSafetyModeCountForTesting();
 103
 104     scoped_ptr<net::URLRequest> request(context_.CreateRequest(
 105         GURL("http://anyurl.com"), net::DEFAULT_PRIORITY, &delegate_));
 106
 107     request->Start();
 108     base::MessageLoop::current()->RunUntilIdle();
 109
 110     EXPECT_EQ(expect_google_safe_search ? 1 : 0,
 111         safe_search_util::GetForceGoogleSafeSearchCountForTesting());
 112     EXPECT_EQ(expect_youtube_safety_mode ? 1 : 0,
 113         safe_search_util::GetForceYouTubeSafetyModeCountForTesting());
 114   }
 115
 116  private:
 117   extensions::EventRouterForwarder* forwarder() {
 118 #if defined(ENABLE_EXTENSIONS)
 119     return forwarder_.get();
 120 #else
 121     return NULL;
 122 #endif
 123   }
 124
 125   content::TestBrowserThreadBundle thread_bundle_;
 126 #if defined(ENABLE_EXTENSIONS)
 127   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 128 #endif
 129   TestingProfile profile_;
 130   BooleanPrefMember enable_referrers_;
 131   BooleanPrefMember force_google_safe_search_;
 132   BooleanPrefMember force_youtube_safety_mode_;
 133   scoped_ptr<net::URLRequest> request_;
 134   net::TestURLRequestContext context_;
 135   net::NetworkDelegate* network_delegate_;
 136   net::TestDelegate delegate_;
 137 };
 138
 139 TEST_F(ChromeNetworkDelegateSafeSearchTest, SafeSearch) {
 140   scoped_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
 141   SetDelegate(delegate.get());
 142
 143   // Loop over all combinations of the two policies.
 144   for (int i = 0; i < 4; i++) {
 145     bool google_safe_search = i % 2;
 146     bool youtube_safety_mode = i / 2;
 147     SetSafeSearch(google_safe_search, youtube_safety_mode);
 148
 149     QueryURL(google_safe_search, youtube_safety_mode);
 150   }
 151 }
 152
 153 // Privacy Mode disables Channel Id if cookies are blocked (cr223191)
 154 class ChromeNetworkDelegatePrivacyModeTest : public testing::Test {
 155  public:
 156   ChromeNetworkDelegatePrivacyModeTest()
 157       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
 158 #if defined(ENABLE_EXTENSIONS)
 159         forwarder_(new extensions::EventRouterForwarder()),
 160 #endif
 161         cookie_settings_(CookieSettings::Factory::GetForProfile(&profile_)
 162                              .get()),
 163         kBlockedSite("http://ads.thirdparty.com"),
 164         kAllowedSite("http://good.allays.com"),
 165         kFirstPartySite("http://cool.things.com"),
 166         kBlockedFirstPartySite("http://no.thirdparties.com") {}
 167
 168   void SetUp() override {
 169     ChromeNetworkDelegate::InitializePrefsOnUIThread(
 170         &enable_referrers_, NULL, NULL, NULL,
 171         profile_.GetTestingPrefService());
 172   }
 173
 174  protected:
 175   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
 176     scoped_ptr<ChromeNetworkDelegate> network_delegate(
 177         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
 178     network_delegate->set_cookie_settings(cookie_settings_);
 179     return network_delegate.Pass();
 180   }
 181
 182   void SetDelegate(net::NetworkDelegate* delegate) {
 183     network_delegate_ = delegate;
 184     context_.set_network_delegate(network_delegate_);
 185   }
 186
 187  protected:
 188   extensions::EventRouterForwarder* forwarder() {
 189 #if defined(ENABLE_EXTENSIONS)
 190     return forwarder_.get();
 191 #else
 192     return NULL;
 193 #endif
 194   }
 195
 196   content::TestBrowserThreadBundle thread_bundle_;
 197 #if defined(ENABLE_EXTENSIONS)
 198   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 199 #endif
 200   TestingProfile profile_;
 201   CookieSettings* cookie_settings_;
 202   BooleanPrefMember enable_referrers_;
 203   scoped_ptr<net::URLRequest> request_;
 204   net::TestURLRequestContext context_;
 205   net::NetworkDelegate* network_delegate_;
 206
 207   const GURL kBlockedSite;
 208   const GURL kAllowedSite;
 209   const GURL kEmptyFirstPartySite;
 210   const GURL kFirstPartySite;
 211   const GURL kBlockedFirstPartySite;
 212 };
 213
 214 TEST_F(ChromeNetworkDelegatePrivacyModeTest, DisablePrivacyIfCookiesAllowed) {
 215   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 216   SetDelegate(delegate.get());
 217
 218   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 219                                                        kEmptyFirstPartySite));
 220 }
 221
 222
 223 TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfCookiesBlocked) {
 224   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 225   SetDelegate(delegate.get());
 226
 227   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
 228                                                        kEmptyFirstPartySite));
 229
 230   cookie_settings_->SetCookieSetting(
 231       ContentSettingsPattern::FromURL(kBlockedSite),
 232       ContentSettingsPattern::Wildcard(),
 233       CONTENT_SETTING_BLOCK);
 234   EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
 235                                                       kEmptyFirstPartySite));
 236 }
 237
 238 TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfThirdPartyBlocked) {
 239   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 240   SetDelegate(delegate.get());
 241
 242   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 243                                                        kFirstPartySite));
 244
 245   profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
 246   EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 247                                                       kFirstPartySite));
 248   profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, false);
 249   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 250                                                        kFirstPartySite));
 251 }
 252
 253 TEST_F(ChromeNetworkDelegatePrivacyModeTest,
 254        DisablePrivacyIfOnlyFirstPartyBlocked) {
 255   scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 256   SetDelegate(delegate.get());
 257
 258   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 259                                                        kBlockedFirstPartySite));
 260
 261   cookie_settings_->SetCookieSetting(
 262       ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
 263       ContentSettingsPattern::Wildcard(),
 264       CONTENT_SETTING_BLOCK);
 265   // Privacy mode is disabled as kAllowedSite is still getting cookies
 266   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
 267                                                        kBlockedFirstPartySite));
 268 }