Move HSTS redirection from URLRequest to URLRequestHTTPJob.

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 2013 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 "net/url_request/url_request_http_job.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "net/base/auth.h"
 #include "net/base/request_priority.h"
 #include "net/base/sdch_observer.h"
 #include "net/base/test_data_directory.h"
 #include "net/cookies/cookie_store_test_helpers.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_transaction_test_util.h"
+#include "net/log/test_net_log.h"
+#include "net/log/test_net_log_entry.h"
+#include "net/log/test_net_log_util.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/cert_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ skipping 23 matching lines @@
 class URLRequestHttpJobTest : public ::testing::Test {
  protected:
   URLRequestHttpJobTest() : context_(true) {
     context_.set_http_transaction_factory(&network_layer_);
 
     // The |test_job_factory_| takes ownership of the interceptor.
     test_job_interceptor_ = new TestJobInterceptor();
     EXPECT_TRUE(test_job_factory_.SetProtocolHandler(
         url::kHttpScheme, base::WrapUnique(test_job_interceptor_)));
     context_.set_job_factory(&test_job_factory_);
-
+    context_.set_net_log(&net_log_);
     context_.Init();
 
     req_ = context_.CreateRequest(GURL("http://www.example.com"),
                                   DEFAULT_PRIORITY, &delegate_);
   }
 
   bool TransactionAcceptsSdchEncoding() {
     base::WeakPtr<MockNetworkTransaction> transaction(
         network_layer_.last_transaction());
     EXPECT_TRUE(transaction);
@@ skipping 25 matching lines @@
   }
 
   MockNetworkLayer network_layer_;
 
   // |test_job_interceptor_| is owned by |test_job_factory_|.
   TestJobInterceptor* test_job_interceptor_;
   URLRequestJobFactoryImpl test_job_factory_;
 
   TestURLRequestContext context_;
   TestDelegate delegate_;
+  TestNetLog net_log_;
   std::unique_ptr<URLRequest> req_;
 };
 
 class URLRequestHttpJobWithMockSocketsTest : public ::testing::Test {
  protected:
   URLRequestHttpJobWithMockSocketsTest()
       : context_(new TestURLRequestContext(true)) {
     context_->set_client_socket_factory(&socket_factory_);
     context_->set_network_delegate(&network_delegate_);
     context_->set_backoff_manager(&manager_);
@@ skipping 495 matching lines @@
 // Confirm we don't advertise SDCH encoding in the case of a POST.
 TEST_F(URLRequestHttpJobTest, SdchAdvertisementPost) {
   EnableSdch();
   req_->set_method("POST");
   test_job_interceptor_->set_main_intercept_job(
       base::WrapUnique(new TestURLRequestHttpJob(req_.get())));
   req_->Start();
   EXPECT_FALSE(TransactionAcceptsSdchEncoding());
 }
 
+TEST_F(URLRequestHttpJobTest, HSTSInternalRedirectTest) {
+  // Setup HSTS state.
+  context_.transport_security_state()->AddHSTS(
+      "upgrade.test", base::Time::Now() + base::TimeDelta::FromSeconds(10),
+      true);
+  ASSERT_TRUE(
+      context_.transport_security_state()->ShouldUpgradeToSSL("upgrade.test"));
+  ASSERT_FALSE(context_.transport_security_state()->ShouldUpgradeToSSL(
+      "no-upgrade.test"));
+
+  struct TestCase {
+    const char* url;
+    bool upgrade_expected;
+    const char* url_expected;
+  } cases[] = {
+      {"http://upgrade.test/", true, "https://upgrade.test/"},
+      {"ws://upgrade.test/", true, "wss://upgrade.test/"},
+      {"http://upgrade.test:123/", true, "https://upgrade.test:123/"},
+      {"ws://upgrade.test:123/", true, "wss://upgrade.test:123/"},
+      {"http://no-upgrade.test/", false, "http://no-upgrade.test/"},
+      {"ws://no-upgrade.test/", false, "ws://no-upgrade.test/"},
+      {"http://no-upgrade.test:123/", false, "http://no-upgrade.test:123/"},
+      {"ws://no-upgrade.test:123/", false, "ws://no-upgrade.test:123/"},
+  };
+
+  for (const auto& test : cases) {
+    SCOPED_TRACE(test.url);
+    TestDelegate d;
+    TestNetworkDelegate network_delegate;
+    std::unique_ptr<URLRequest> r(
+        context_.CreateRequest(GURL(test.url), DEFAULT_PRIORITY, &d));
+
+    net_log_.Clear();
+    r->Start();
+    base::RunLoop().Run();
+
+    if (test.upgrade_expected) {
+      net::TestNetLogEntry::List entries;
+      net_log_.GetEntries(&entries);
+      int redirects = 0;
+      for (const auto& entry : entries) {
+        if (entry.type == net::NetLog::TYPE_URL_REQUEST_REDIRECT_JOB) {
+          redirects++;
+          std::string value;
+          EXPECT_TRUE(entry.GetStringValue("reason", &value));
+          EXPECT_EQ("HSTS", value);
+        }
+      }
+      EXPECT_EQ(1, redirects);
+      EXPECT_EQ(1, d.received_redirect_count());
+      EXPECT_EQ(2u, r->url_chain().size());
+    } else {
+      EXPECT_EQ(0, d.received_redirect_count());
+      EXPECT_EQ(1u, r->url_chain().size());
+    }
+    EXPECT_EQ(GURL(test.url_expected), r->url());
+  }
+}
+
 class MockSdchObserver : public SdchObserver {
  public:
   MockSdchObserver() {}
   MOCK_METHOD2(OnDictionaryAdded,
                void(const GURL& request_url, const std::string& server_hash));
   MOCK_METHOD1(OnDictionaryRemoved, void(const std::string& server_hash));
   MOCK_METHOD1(OnDictionaryUsed, void(const std::string& server_hash));
   MOCK_METHOD2(OnGetDictionary,
                void(const GURL& request_url, const GURL& dictionary_url));
   MOCK_METHOD0(OnClearDictionaries, void());
@@ skipping 299 matching lines @@
                     create_helper.release());
   req_->SetLoadFlags(LOAD_DISABLE_CACHE);
   req_->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_->status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 #endif  // !defined(OS_IOS)
 
+class URLRequestHttpJobInternalRedirectTest : public ::testing::Test {

[mmenke, 2016/06/17 16:40:29]

Remove this.

[Mike West, 2016/06/17 19:44:34]

Ugh. Yes, thank you. :)

+ protected:
+  URLRequestHttpJobInternalRedirectTest()
+      : context_(new TestURLRequestContext(true)) {
+    std::unique_ptr<HttpNetworkSession::Params> params(
+        new HttpNetworkSession::Params);
+    context_->set_enable_brotli(true);
+    context_->set_http_network_session_params(std::move(params));
+    context_->set_client_socket_factory(&socket_factory_);
+    context_->Init();
+  }
+
+  MockClientSocketFactory socket_factory_;
+  std::unique_ptr<TestURLRequestContext> context_;
+};
+
 }  // namespace
 
 }  // namespace net