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/"},
+    {"http://upgrade.test:123/", true, "https://upgrade.test:123/"},
+    {"http://no-upgrade.test/", false, "http://no-upgrade.test/"},
+    {"http://no-upgrade.test:123/", false, "http://no-upgrade.test:123/"},
+// iOS doesn't support websockets; see the comments above
+// URLRequestHttpJobWebSocketTest for detail.
+#if !defined(OS_IOS)

[Mike West, 2016/06/20 13:36:41]

mmenke@: WebSockets aren't enabled on iOS. I'm disabling this portion of the
test, similar to what we're doing at the bottom of the file for the
'URLRequestHttpJobWebSocketTest' tests.

I'm following up on your suggestion there to move away from hard-coded
feature=>OS mappings in https://codereview.chromium.org/2082603002.

+    {"ws://upgrade.test/", true, "wss://upgrade.test/"},
+    {"ws://upgrade.test:123/", true, "wss://upgrade.test:123/"},
+    {"ws://no-upgrade.test/", false, "ws://no-upgrade.test/"},
+    {"ws://no-upgrade.test:123/", false, "ws://no-upgrade.test:123/"},
+#endif  // !defined(OS_IOS)
+  };
+
+  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 302 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_->status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 #endif  // !defined(OS_IOS)
 
 }  // namespace
 
 }  // namespace net