First-Party Cookies: Wire it up as an experimental web platform feature

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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_member.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
-#if defined(ENABLE_EXTENSIONS)
 class ChromeNetworkDelegateTest : public testing::Test {
  protected:
   ChromeNetworkDelegateTest()
-      : forwarder_(new extensions::EventRouterForwarder()) {
+#if defined(ENABLE_EXTENSIONS)
+      : forwarder_(new extensions::EventRouterForwarder())
+#endif
+  {
   }
 
   void SetUp() override {
     never_throttle_requests_original_value_ =
         ChromeNetworkDelegate::g_never_throttle_requests_;
     ChromeNetworkDelegate::g_never_throttle_requests_ = false;
   }
 
   void TearDown() override {
     ChromeNetworkDelegate::g_never_throttle_requests_ =
         never_throttle_requests_original_value_;
   }
 
   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
     return make_scoped_ptr(
-        new ChromeNetworkDelegate(forwarder_.get(), &pref_member_));
+        new ChromeNetworkDelegate(forwarder(), &pref_member_));
   }
 
+#if defined(ENABLE_EXTENSIONS)
   // Implementation moved here for access to private bits.
   void NeverThrottleLogicImpl() {
     scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
 
     net::TestURLRequestContext context;
     scoped_ptr<net::URLRequest> extension_request(context.CreateRequest(
         GURL("http://example.com/"), net::DEFAULT_PRIORITY, NULL, NULL));
     extension_request->set_first_party_for_cookies(
         GURL("chrome-extension://abcdef/bingo.html"));
     scoped_ptr<net::URLRequest> web_page_request(context.CreateRequest(
@@ skipping 13 matching lines @@
     // ChromeNetworkDelegate.
     //
     // We test the side effects of the flag rather than just the flag
     // itself (which we did above) to help ensure that a changed
     // implementation would show the same behavior, i.e. all instances
     // of ChromeNetworkDelegate after the flag is set obey the flag.
     scoped_ptr<ChromeNetworkDelegate> second_delegate(CreateNetworkDelegate());
     ASSERT_FALSE(delegate->OnCanThrottleRequest(*extension_request));
     ASSERT_FALSE(delegate->OnCanThrottleRequest(*web_page_request));
   }
+#endif
 
  private:
+  extensions::EventRouterForwarder* forwarder() {
+#if defined(ENABLE_EXTENSIONS)

[mmenke, 2015/02/20 16:30:39]

All these ifdefs seem ugly, and this setup all seems very specific to the
NeverThrottleTest.  Maybe rename this test fixture to
ChromeNetworkDelegateThrottleTest, and don't have your new test inherit from it?
 You don't even need to use a test fixture in your new one.

[Mike West, 2015/02/23 15:51:17]

I either have ifdefs here, or in the new test, as I can't construct a
ChromeNetworkDelegate without knowing whether or not ENABLE_EXTENSIONS is set
(and either adding an EventRouterForwarder or not). It seemed simpler to extract
those bits here, but I take your point.

+    return forwarder_.get();
+#else
+    return NULL;
+#endif
+  }
+
   bool never_throttle_requests_original_value_;
   base::MessageLoopForIO message_loop_;
 
+#if defined(ENABLE_EXTENSIONS)
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
+#endif
   BooleanPrefMember pref_member_;
 };
 
+#if defined(ENABLE_EXTENSIONS)
 TEST_F(ChromeNetworkDelegateTest, NeverThrottleLogic) {
   NeverThrottleLogicImpl();
 }
 #endif  // defined(ENABLE_EXTENSIONS)
 
+TEST_F(ChromeNetworkDelegateTest, EnableFirstPartyCookiesIffFlagEnabled) {
+  scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
+
+  // Off by default, on if the switch is present.
+  EXPECT_FALSE(delegate->FirstPartyCookieExperimentEnabled());
+  delegate->SetExperimentalWebPlatformFeaturesEnabled();
+  EXPECT_TRUE(delegate->FirstPartyCookieExperimentEnabled());
+}
+
 class ChromeNetworkDelegateSafeSearchTest : public testing::Test {
  public:
   ChromeNetworkDelegateSafeSearchTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 #if defined(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
   }
 
   void SetUp() override {
@@ skipping 200 matching lines @@
                                                        kBlockedFirstPartySite));
 
   cookie_settings_->SetCookieSetting(
       ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTING_BLOCK);
   // Privacy mode is disabled as kAllowedSite is still getting cookies
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 }
-