Referrer Policy: Add new policies to URLRequest.

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 2809 matching lines @@
       EXPECT_TRUE(test_server_.Start());
     }
 
     return is_success;
   }
 
   LocalHttpTestServer* test_server() {
     return &test_server_;
   }
 
+  void VerifyReferrerPolicyAfterRedirect(URLRequest::ReferrerPolicy policy,
+                                         SpawnedTestServer::Type origin,
+                                         SpawnedTestServer::Type destination,
+                                         const std::string& referrer,
+                                         const std::string& expected) {
+    // Spin up the servers.
+    SpawnedTestServer https_test_server(
+        SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+        base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+    ASSERT_TRUE(https_test_server.Start());
+    ASSERT_TRUE(test_server_.Start());

[mmenke, 2014/11/19 16:29:03]

All the server starting and stopping, particularly in the Android case, where
they're run on the host machine, makes me nervous.  We've had timeout issues
started the test server in browser tests before, and 8 or 12 started servers
seems like a lot.

Maybe divide up test by source/dest server, rather than by policy?  One would
test the cross site HTTPS->HTTPS transition for all policies, etc.

[Mike West, 2014/11/20 10:45:30]

That seems reasonable. It still requires us to spin up 10 servers for the 6
distinct possibilities. I'm not sure whether reducing that is a good idea (as,
at the limit, it would mean dumping all the referrer policy tests into one test,
spinning up the four server types (http A, http B, https A, and https B), and
running all the tests).

If you'd like me to go that route, I can, but I won't like it. :(

[mmenke, 2014/11/20 16:23:45]

Starting two servers per test is much less likely to run into server startup
performance issues than 8 per test.  Also didn't like relying on servers being
restartable.

+
+    // Create and execute the request.
+    GURL destination_url = destination == SpawnedTestServer::TYPE_HTTP
+                               ? test_server_.GetURL(std::string())
+                               : https_test_server.GetURL(std::string());
+    GURL origin_url =
+        origin == SpawnedTestServer::TYPE_HTTP
+            ? test_server_.GetURL("server-redirect?" + destination_url.spec())
+            : https_test_server.GetURL("server-redirect?" +
+                                       destination_url.spec());
+
+    std::string original_referrer = referrer;
+    ReplaceFirstSubstringAfterOffset(&original_referrer, 0, "[HTTP_ORIGIN]",
+                                     test_server_.GetURL(std::string()).spec());
+    ReplaceFirstSubstringAfterOffset(
+        &original_referrer, 0, "[HTTPS_ORIGIN]",
+        https_test_server.GetURL(std::string()).spec());
+
+    std::string expected_referrer = expected;
+    ReplaceFirstSubstringAfterOffset(&expected_referrer, 0, "[HTTP_ORIGIN]",
+                                     test_server_.GetURL(std::string()).spec());
+    ReplaceFirstSubstringAfterOffset(
+        &expected_referrer, 0, "[HTTPS_ORIGIN]",
+        https_test_server.GetURL(std::string()).spec());
+
+    TestDelegate d;
+    scoped_ptr<URLRequest> req(
+        default_context_.CreateRequest(origin_url, DEFAULT_PRIORITY, &d, NULL));
+    req->set_referrer_policy(policy);
+    req->SetReferrer(original_referrer);
+    req->Start();
+    base::RunLoop().Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_EQ(1, d.received_redirect_count());
+    EXPECT_EQ(destination_url, req->url());
+    EXPECT_EQ(expected_referrer, req->referrer());
+
+    ASSERT_TRUE(test_server_.Stop());
+    ASSERT_TRUE(https_test_server.Stop());
+  }
+
  protected:
   LocalHttpTestServer test_server_;
 };
 
 // In this unit test, we're using the HTTPTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.redirect.com".
 // The HTTPTestServer will return a 302 response, which we should not
 // follow.
 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 1066 matching lines @@
             << " Parameter = \"" << test_file << "\"";
       } else {
         EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
         EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r->status().error())
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
 
-TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) {
-  ASSERT_TRUE(test_server_.Start());
+TEST_F(URLRequestTestHTTP, ReferrerPolicyClearRefererOnTransition) {

[mmenke, 2014/11/19 16:29:04]

It's unexciting, but for completeness, should test NEVER_CLEAR_REFERRER, too.

+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTPS,
+      "https://www.referrer.com/path/to/file.html",
+      "https://www.referrer.com/path/to/file.html");
 
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
-  ASSERT_TRUE(https_test_server.Start());
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTP,
+      "https://www.referrer.com/path/to/file.html", "");
 
-  // An https server is sent a request with an https referer,
-  // and responds with a redirect to an http url. The http
-  // server should not be sent the referer.
-  GURL http_destination = test_server_.GetURL(std::string());
-  TestDelegate d;
-  scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      https_test_server.GetURL("server-redirect?" + http_destination.spec()),
-      DEFAULT_PRIORITY, &d, NULL));
-  req->SetReferrer("https://www.referrer.com/");
-  req->Start();
-  base::RunLoop().Run();
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTPS,
+      "http://www.referrer.com/path/to/file.html",
+      "http://www.referrer.com/path/to/file.html");
 
-  EXPECT_EQ(1, d.response_started_count());
-  EXPECT_EQ(1, d.received_redirect_count());
-  EXPECT_EQ(http_destination, req->url());
-  EXPECT_EQ(std::string(), req->referrer());
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTP,
+      "http://www.referrer.com/path/to/file.html",
+      "http://www.referrer.com/path/to/file.html");
+}
+
+TEST_F(URLRequestTestHTTP, ReferrerPolicyNeverClearReferer) {
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::NEVER_CLEAR_REFERRER, SpawnedTestServer::TYPE_HTTPS,
+      SpawnedTestServer::TYPE_HTTPS,
+      "https://www.referrer.com/path/to/file.html",
+      "https://www.referrer.com/path/to/file.html");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::NEVER_CLEAR_REFERRER, SpawnedTestServer::TYPE_HTTPS,
+      SpawnedTestServer::TYPE_HTTP,
+      "https://www.referrer.com/path/to/file.html",
+      "https://www.referrer.com/path/to/file.html");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::NEVER_CLEAR_REFERRER, SpawnedTestServer::TYPE_HTTP,
+      SpawnedTestServer::TYPE_HTTPS,
+      "http://www.referrer.com/path/to/file.html",
+      "http://www.referrer.com/path/to/file.html");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::NEVER_CLEAR_REFERRER, SpawnedTestServer::TYPE_HTTP,
+      SpawnedTestServer::TYPE_HTTP, "http://www.referrer.com/path/to/file.html",
+      "http://www.referrer.com/path/to/file.html");
+}
+
+TEST_F(URLRequestTestHTTP, ReferrerPolicyReduceReferrerGranularity) {

[mmenke, 2014/11/19 16:29:03]

We actually have 6 cases for all these tests, not 4:

4 transition types:  HTTP->HTTP, HTTP->HTTPS, HTTPS->HTTP, HTTPS->HTTPS.

And then we have cross origin and same origin (We don't have same origin
variants of the HTTPS->HTTP and HTTP->HTTPS transitions, of course)

+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTPS,
+      "[HTTPS_ORIGIN]path/to/file.html", "[HTTPS_ORIGIN]path/to/file.html");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTP,
+      "[HTTPS_ORIGIN]path/to/file.html", "");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTPS,
+      "[HTTP_ORIGIN]path/to/file.html", "[HTTP_ORIGIN]");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTP,
+      "[HTTP_ORIGIN]path/to/file.html", "[HTTP_ORIGIN]path/to/file.html");
+}
+
+TEST_F(URLRequestTestHTTP, ReferrerPolicyOriginOnly) {
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTPS,
+      "[HTTPS_ORIGIN]path/to/file.html", "[HTTPS_ORIGIN]path/to/file.html");

[mmenke, 2014/11/19 16:29:03]

Shouldn't we test HTTPS cross origin, too, where we should clear the referrer?

[Mike West, 2014/11/20 10:45:30]

Added cross-origin HTTPS tests.

+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::TYPE_HTTP,
+      "[HTTPS_ORIGIN]path/to/file.html", "[HTTPS_ORIGIN]");

[mmenke, 2014/11/19 16:29:04]

I thought we should clear the referrer in this case?

[Mike West, 2014/11/20 10:45:30]

No, we clear it for "REDUCED_WHATEVER_...", but "ORIGIN_ONLY" always sends the
origin. The use-case is a service like Facebook, which wishes to have full
internal referrer information for debugging and etc, and wants (even insecure)
external folks to know that their traffic is totally coming from Facebook, but
doesn't want to leak URL details cross-origin.

+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTPS,
+      "[HTTP_ORIGIN]path/to/file.html", "[HTTP_ORIGIN]");
+
+  VerifyReferrerPolicyAfterRedirect(
+      URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
+      SpawnedTestServer::TYPE_HTTP, SpawnedTestServer::TYPE_HTTP,
+      "[HTTP_ORIGIN]path/to/file.html", "[HTTP_ORIGIN]path/to/file.html");
 }
 
 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(std::string());
   GURL original_url =
       test_server_.GetURL("server-redirect?" + destination_url.spec());
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
@@ skipping 4672 matching lines @@
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net