Reset the Lo-Fi main frame state when there is a new main frame request

components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options_unittest.cc

 // Copyright 2014 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 "components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/proxy/proxy_server.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 const char kChromeProxyHeader[] = "chrome-proxy";
-const char kOtherProxy[] = "testproxy:17";
 
 const char kVersion[] = "0.1.2.3";
 const char kExpectedBuild[] = "2";
 const char kExpectedPatch[] = "3";
 const char kExpectedCredentials[] = "96bd72ec4a050ba60981743d41787768";
 const char kExpectedSession[] = "0-1633771873-1633771873-1633771873";
 
 const char kTestKey2[] = "test-key2";
 const char kExpectedCredentials2[] = "c911fdb402f578787562cf7f00eda972";
 const char kExpectedSession2[] = "0-1633771873-1633771873-1633771873";
@@ skipping 101 matching lines @@
   }
 
   TestDataReductionProxyParams* params() {
     return test_context_->config()->test_params();
   }
 
   TestDataReductionProxyRequestOptions* request_options() {
     return request_options_.get();
   }
 
-  void VerifyExpectedHeader(const std::string& proxy_uri,
-                            const std::string& expected_header) {
+  void VerifyExpectedHeader(const std::string& expected_header) {
     test_context_->RunUntilIdle();
     net::HttpRequestHeaders headers;
-    request_options_->MaybeAddRequestHeader(
-        proxy_uri.empty() ? net::ProxyServer()
-                          : net::ProxyServer::FromURI(
-                                proxy_uri, net::ProxyServer::SCHEME_HTTP),
-        &headers);
+    request_options_->AddRequestHeader(&headers);
     if (expected_header.empty()) {
       EXPECT_FALSE(headers.HasHeader(kChromeProxyHeader));
       return;
     }
     EXPECT_TRUE(headers.HasHeader(kChromeProxyHeader));
     std::string header_value;
     headers.GetHeader(kChromeProxyHeader, &header_value);
     EXPECT_EQ(expected_header, header_value);
   }
 
@@ skipping 22 matching lines @@
                         "d7c1c34ef6b90303b01c48a6c1db6419", std::string(),
                         kClientStr, kExpectedBuild, kExpectedPatch,
                         std::vector<std::string>(), &expected_header2);
 
   CreateRequestOptions(kVersion);
   test_context_->RunUntilIdle();
 
   // Now set a key.
   request_options()->SetKeyOnIO(kTestKey2);
 
-  // Don't write headers if the proxy is invalid.
-  VerifyExpectedHeader(std::string(), std::string());
-
-  // Don't write headers with a valid proxy, that's not a data reduction proxy.
-  VerifyExpectedHeader(kOtherProxy, std::string());
-
-  // Write headers with a valid data reduction proxy.
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  // Write headers.
+  VerifyExpectedHeader(expected_header);
 
   // Fast forward 24 hours. The header should be the same.
   request_options()->set_offset(base::TimeDelta::FromSeconds(24 * 60 * 60));
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  VerifyExpectedHeader(expected_header);
 
   // Fast forward one more second. The header should be new.
   request_options()->set_offset(base::TimeDelta::FromSeconds(24 * 60 * 60 + 1));
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header2);
+  VerifyExpectedHeader(expected_header2);
 }
 
 TEST_F(DataReductionProxyRequestOptionsTest, AuthorizationIgnoresEmptyKey) {
   std::string expected_header;
   SetHeaderExpectations(kExpectedSession, kExpectedCredentials, std::string(),
                         kClientStr, kExpectedBuild, kExpectedPatch,
                         std::vector<std::string>(), &expected_header);
   CreateRequestOptions(kVersion);
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  VerifyExpectedHeader(expected_header);
 
   // Now set an empty key. The auth handler should ignore that, and the key
   // remains |kTestKey|.
   request_options()->SetKeyOnIO(std::string());
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  VerifyExpectedHeader(expected_header);
 }
 
 TEST_F(DataReductionProxyRequestOptionsTest, SecureSession) {
   std::string expected_header;
   SetHeaderExpectations(std::string(), std::string(), kSecureSession,
                         kClientStr, kExpectedBuild, kExpectedPatch,
                         std::vector<std::string>(), &expected_header);
 
   CreateRequestOptions(kVersion);
   request_options()->SetSecureSession(kSecureSession);
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  VerifyExpectedHeader(expected_header);
 }
 
 TEST_F(DataReductionProxyRequestOptionsTest, ParseExperiments) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       data_reduction_proxy::switches::kDataReductionProxyExperiment,
       "staging,\"foo,bar\"");
   std::vector<std::string> expected_experiments;
   expected_experiments.push_back("staging");
   expected_experiments.push_back("\"foo,bar\"");
   std::string expected_header;
   SetHeaderExpectations(kExpectedSession, kExpectedCredentials, std::string(),
                         kClientStr, kExpectedBuild, kExpectedPatch,
                         expected_experiments, &expected_header);
 
   CreateRequestOptions(kVersion);
-  VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+  VerifyExpectedHeader(expected_header);
 }
 
 TEST_F(DataReductionProxyRequestOptionsTest, ParseExperimentsFromFieldTrial) {
   const char kFieldTrialGroupFoo[] = "enabled_foo";
   const char kFieldTrialGroupBar[] = "enabled_bar";
   const char kExperimentFoo[] = "foo";
   const char kExperimentBar[] = "bar";
   const struct {
     std::string field_trial_group;
     std::string command_line_experiment;
@@ skipping 35 matching lines @@
         params::GetServerExperimentsFieldTrialName(), test.field_trial_group);
 
     if (!test.expected_experiment.empty())
       expected_experiments.push_back(test.expected_experiment);
 
     SetHeaderExpectations(kExpectedSession, kExpectedCredentials, std::string(),
                           kClientStr, kExpectedBuild, kExpectedPatch,
                           expected_experiments, &expected_header);
 
     CreateRequestOptions(kVersion);
-    VerifyExpectedHeader(params()->DefaultOrigin(), expected_header);
+    VerifyExpectedHeader(expected_header);
   }
 }
 
 TEST_F(DataReductionProxyRequestOptionsTest, GetSessionKeyFromRequestHeaders) {
   const struct {
     std::string chrome_proxy_header_key;
     std::string chrome_proxy_header_value;
     std::string expected_session_key;
   } tests[] = {
       {"chrome-proxy", "something=something_else, s=123, key=value", "123"},
@@ skipping 20 matching lines @@
 
     std::string session_key =
         request_options()->GetSessionKeyFromRequestHeaders(request_headers);
     EXPECT_EQ(test.expected_session_key, session_key)
         << test.chrome_proxy_header_key << ":"
         << test.chrome_proxy_header_value;
   }
 }
 
 }  // namespace data_reduction_proxy