DRP: Add check that ECT header is present when CPAT header is present.

components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate_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_network_delegate.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 615 matching lines @@
   std::unique_ptr<net::URLRequest> fake_request(
       FetchURLRequest(GURL(kTestURL), nullptr, std::string(), 0));
 
   net::ProxyInfo data_reduction_proxy_info;
   net::ProxyRetryInfoMap proxy_retry_info;
   std::string data_reduction_proxy;
   base::TrimString(params()->DefaultOrigin(), "/", &data_reduction_proxy);
   data_reduction_proxy_info.UseNamedProxy(data_reduction_proxy);
 
   net::HttpRequestHeaders headers;
+  // Call network delegate methods to ensure that appropriate chrome proxy
+  // headers get added/removed.
+  network_delegate()->NotifyBeforeStartTransaction(
+      fake_request.get(),
+      base::Bind(&DataReductionProxyNetworkDelegateTest::DelegateStageDone,
+                 base::Unretained(this)),
+      &headers);
   network_delegate()->NotifyBeforeSendHeaders(fake_request.get(),
                                               data_reduction_proxy_info,
                                               proxy_retry_info, &headers);
 
   EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
   std::string header_value;
   headers.GetHeader(chrome_proxy_header(), &header_value);
   EXPECT_TRUE(header_value.find("ps=") != std::string::npos);
   EXPECT_TRUE(header_value.find("sid=") != std::string::npos);
 }
@@ skipping 190 matching lines @@
 
     test_network_quality_estimator()->set_effective_connection_type(
         net::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
 
     std::unique_ptr<net::URLRequest> request = context()->CreateRequest(
         GURL(kTestURL), net::RequestPriority::IDLE, nullptr);
     request->SetLoadFlags(test.main_frame ? net::LOAD_MAIN_FRAME_DEPRECATED
                                           : 0);
     lofi_decider()->SetIsUsingLoFi(test.lofi_on);
     io_data()->request_options()->SetSecureSession("fake-session");
+
+    // Call network delegate methods to ensure that appropriate chrome proxy
+    // headers get added/removed.
+    network_delegate()->NotifyBeforeStartTransaction(
+        request.get(),
+        base::Bind(&DataReductionProxyNetworkDelegateTest::DelegateStageDone,
+                   base::Unretained(this)),
+        &headers);
     network_delegate()->NotifyBeforeSendHeaders(
         request.get(), data_reduction_proxy_info, proxy_retry_info, &headers);
     DataReductionProxyData* data =
         DataReductionProxyData::GetData(*request.get());
     if (!test.used_data_reduction_proxy) {
       EXPECT_FALSE(data);
     } else {
       EXPECT_TRUE(data);
       EXPECT_EQ(test.main_frame ? net::EFFECTIVE_CONNECTION_TYPE_OFFLINE
                                 : net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
@@ skipping 55 matching lines @@
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, RedirectRequestDataCleared) {
   Init(false, false);
   net::ProxyInfo data_reduction_proxy_info;
   std::string data_reduction_proxy;
   base::TrimString(params()->DefaultOrigin(), "/", &data_reduction_proxy);
   data_reduction_proxy_info.UseNamedProxy(data_reduction_proxy);
 
   // Main frame loaded. Lo-Fi should be used.
-  net::HttpRequestHeaders headers;
+  net::HttpRequestHeaders headers_original;
   net::ProxyRetryInfoMap proxy_retry_info;
 
   test_network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
 
   std::unique_ptr<net::URLRequest> request = context()->CreateRequest(
       GURL(kTestURL), net::RequestPriority::IDLE, nullptr);
   request->SetLoadFlags(net::LOAD_MAIN_FRAME_DEPRECATED);
   lofi_decider()->SetIsUsingLoFi(true);
   io_data()->request_options()->SetSecureSession("fake-session");
+
+  // Call network delegate methods to ensure that appropriate chrome proxy
+  // headers get added/removed.
+  network_delegate()->NotifyBeforeStartTransaction(
+      request.get(),
+      base::Bind(&DataReductionProxyNetworkDelegateTest::DelegateStageDone,
+                 base::Unretained(this)),
+      &headers_original);
   network_delegate()->NotifyBeforeSendHeaders(
-      request.get(), data_reduction_proxy_info, proxy_retry_info, &headers);
+      request.get(), data_reduction_proxy_info, proxy_retry_info,
+      &headers_original);
   DataReductionProxyData* data =
       DataReductionProxyData::GetData(*request.get());
 
   EXPECT_TRUE(data);
   EXPECT_EQ(net::EFFECTIVE_CONNECTION_TYPE_OFFLINE,
             data->effective_connection_type());
   EXPECT_TRUE(data->used_data_reduction_proxy());
   EXPECT_EQ(GURL(kTestURL), data->request_url());
   EXPECT_EQ("fake-session", data->session_key());
   EXPECT_TRUE(data->lofi_requested());
 
   data_reduction_proxy_info.UseNamedProxy("port.of.other.proxy");
 
   // Simulate a redirect even though the same URL is used. Should clear
   // DataReductionProxyData.
   network_delegate()->NotifyBeforeRedirect(request.get(), GURL(kTestURL));
   data = DataReductionProxyData::GetData(*request.get());
   EXPECT_FALSE(data);
 
   // Call NotifyBeforeSendHeaders again with different proxy info to check that
-  // new data isn't added.
+  // new data isn't added. Use a new set of headers since the redirected HTTP
+  // jobs do not reuse headers from the previous jobs. Also, call network
+  // delegate methods to ensure that appropriate chrome proxy headers get
+  // added/removed.
+  net::HttpRequestHeaders headers_redirect;
+  network_delegate()->NotifyBeforeStartTransaction(
+      request.get(),
+      base::Bind(&DataReductionProxyNetworkDelegateTest::DelegateStageDone,
+                 base::Unretained(this)),
+      &headers_redirect);
   network_delegate()->NotifyBeforeSendHeaders(
-      request.get(), data_reduction_proxy_info, proxy_retry_info, &headers);
+      request.get(), data_reduction_proxy_info, proxy_retry_info,
+      &headers_redirect);
   data = DataReductionProxyData::GetData(*request.get());
   EXPECT_FALSE(data);
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, NetHistograms) {
   Init(false, false);
   const std::string kReceivedValidOCLHistogramName =
       "Net.HttpContentLengthWithValidOCL";
   const std::string kOriginalValidOCLHistogramName =
       "Net.HttpOriginalContentLengthWithValidOCL";
@@ skipping 364 matching lines @@
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[0], true, true);
 
   // When the ECT is set to a different value, the response should still be
   // served from the cache.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[1], true, true);
 }
 
 }  // namespace
 
 }  // namespace data_reduction_proxy