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

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 <string>
@@ skipping 33 matching lines @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace data_reduction_proxy {
 namespace {
 
 using TestNetworkDelegate = net::NetworkDelegateImpl;
 
 const char kChromeProxyHeader[] = "chrome-proxy";
+const char kOtherProxy[] = "testproxy:17";
 
 #if defined(OS_ANDROID)
 const Client kClient = Client::CHROME_ANDROID;
 #elif defined(OS_IOS)
 const Client kClient = Client::CHROME_IOS;
 #elif defined(OS_MACOSX)
 const Client kClient = Client::CHROME_MAC;
 #elif defined(OS_CHROMEOS)
 const Client kClient = Client::CHROME_CHROMEOS;
 #elif defined(OS_LINUX)
@@ skipping 20 matching lines @@
   bool IsUsingLoFiMode(const net::URLRequest& request) const override {
     return should_request_lofi_resource_;
   }
 
   void SetIsUsingLoFiMode(bool should_request_lofi_resource) {
     should_request_lofi_resource_ = should_request_lofi_resource;
   }
 
   bool MaybeAddLoFiDirectiveToHeaders(
       const net::URLRequest& request,
-      net::HttpRequestHeaders* headers,
-      const net::ProxyServer& proxy_server,
-      DataReductionProxyConfig* config) const override {
+      net::HttpRequestHeaders* headers) const override {
     if (should_request_lofi_resource_) {
       const char kChromeProxyHeader[] = "Chrome-Proxy";
       std::string header_value;
 
       if (headers->HasHeader(kChromeProxyHeader)) {
         headers->GetHeader(kChromeProxyHeader, &header_value);
         headers->RemoveHeader(kChromeProxyHeader);
         header_value += ", ";
       }
 
@@ skipping 47 matching lines @@
 
     std::unique_ptr<TestLoFiUIService> lofi_ui_service(new TestLoFiUIService());
     lofi_ui_service_ = lofi_ui_service.get();
     test_context_->io_data()->set_lofi_ui_service(std::move(lofi_ui_service));
 
     context_.Init();
 
     test_context_->EnableDataReductionProxyWithSecureProxyCheckSuccess();
   }
 
-  static void VerifyLoFiHeader(bool expected_lofi_used,
+  static void VerifyLoFiHeader(bool expected_data_reduction_proxy_used,

[tbansal1, 2016/05/06 23:36:51]

s/verifyLoFiHeader/VerifyHeaders/

[megjablon, 2016/05/07 00:29:08]

Done.

+                               bool expected_lofi_used,
                                const net::HttpRequestHeaders& headers) {
-    EXPECT_TRUE(headers.HasHeader(kChromeProxyHeader));
+    EXPECT_EQ(expected_data_reduction_proxy_used,
+              headers.HasHeader(kChromeProxyHeader));

[tbansal1, 2016/05/06 23:36:51]

#include
components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h

[megjablon, 2016/05/07 00:29:08]

Done.

     std::string header_value;
     headers.GetHeader(kChromeProxyHeader, &header_value);
-    EXPECT_EQ(expected_lofi_used,
+    EXPECT_EQ(expected_data_reduction_proxy_used && expected_lofi_used,
               header_value.find("q=low") != std::string::npos);
   }
 
   void VerifyWasLoFiModeActiveOnMainFrame(bool expected_value) {
     test_context_->RunUntilIdle();
     EXPECT_EQ(expected_value,
               test_context_->settings()->WasLoFiModeActiveOnMainFrame());
   }
 
   void VerifyDidNotifyLoFiResponse(bool lofi_response) const {
@@ skipping 51 matching lines @@
   }
 
   TestDataReductionProxyParams* params() const {
     return test_context_->config()->test_params();
   }
 
   TestDataReductionProxyConfig* config() const {
     return test_context_->config();
   }
 
+  TestDataReductionProxyIOData* io_data() const {
+    return test_context_->io_data();
+  }
+
   TestLoFiDecider* lofi_decider() const { return lofi_decider_; }
 
  private:
   int64_t GetSessionNetworkStatsInfoInt64(const char* key) const {
     const DataReductionProxyNetworkDelegate* drp_network_delegate =
         reinterpret_cast<const DataReductionProxyNetworkDelegate*>(
             context_.network_delegate());
 
     std::unique_ptr<base::DictionaryValue> session_network_stats_info =
         base::DictionaryValue::From(base::WrapUnique(
@@ skipping 35 matching lines @@
   headers.GetHeader(kChromeProxyHeader, &header_value);
   EXPECT_TRUE(header_value.find("ps=") != std::string::npos);
   EXPECT_TRUE(header_value.find("sid=") != std::string::npos);
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, LoFiTransitions) {
   // Enable Lo-Fi.
   const struct {
     bool lofi_switch_enabled;
     bool auto_lofi_enabled;
+    bool is_data_reduction_proxy;
   } tests[] = {
       {
-          // Lo-Fi enabled through switch.
-          true, false,
+          // Lo-Fi enabled through switch and not using a Data Reduction Proxy.
+          true, false, false,
       },
       {
-          // Lo-Fi enabled through field trial.
-          false, true,
+          // Lo-Fi enabled through switch and using a Data Reduction Proxy.
+          true, false, true,
+      },
+      {
+          // Lo-Fi enabled through field trial and not using a Data Reduction
+          // Proxy.
+          false, true, false,
+      },
+      {
+          // Lo-Fi enabled through field trial and using a Data Reduction Proxy.
+          false, true, true,
       },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     if (tests[i].lofi_switch_enabled) {
       base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
           switches::kDataReductionProxyLoFi,
           switches::kDataReductionProxyLoFiValueAlwaysOn);
     }
     base::FieldTrialList field_trial_list(nullptr);
     if (tests[i].auto_lofi_enabled) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
     config()->SetNetworkProhibitivelySlow(tests[i].auto_lofi_enabled);
+    io_data()->SetLoFiModeActiveOnMainFrame(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);
+    std::string proxy;
+    if (tests[i].is_data_reduction_proxy)
+      base::TrimString(params()->DefaultOrigin(), "/", &proxy);
+    else
+      base::TrimString(kOtherProxy, "/", &proxy);
+    data_reduction_proxy_info.UseNamedProxy(proxy);
 
     {
       // Main frame loaded. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
 
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME);
       lofi_decider()->SetIsUsingLoFiMode(
           config()->ShouldEnableLoFiMode(*fake_request.get()));
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(true, headers);
-      VerifyWasLoFiModeActiveOnMainFrame(true);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy, true, headers);
+      VerifyWasLoFiModeActiveOnMainFrame(tests[i].is_data_reduction_proxy);
     }
 
     {
       // Lo-Fi is already off. Lo-Fi should not be used.
       net::HttpRequestHeaders headers;
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
       lofi_decider()->SetIsUsingLoFiMode(false);
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(false, headers);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy, false, headers);
       // Not a mainframe request, WasLoFiModeActiveOnMainFrame should still be
-      // true.
-      VerifyWasLoFiModeActiveOnMainFrame(true);
+      // true if the proxy is a Data Reduction Proxy.
+      VerifyWasLoFiModeActiveOnMainFrame(tests[i].is_data_reduction_proxy);
     }
 
     {
       // Lo-Fi is already on. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
 
       lofi_decider()->SetIsUsingLoFiMode(true);
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(true, headers);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy,
+                       tests[i].is_data_reduction_proxy, headers);

[tbansal1, 2016/05/06 23:36:51]

nit: For the second argument, can you not just pass true as before because in
verifyLoFiHeader, you are checking again that DRP is enabled?

[megjablon, 2016/05/07 00:29:08]

Whoops yep, missed switching this one.

       // Not a mainframe request, WasLoFiModeActiveOnMainFrame should still be
-      // true.
-      VerifyWasLoFiModeActiveOnMainFrame(true);
+      // true if the proxy is a Data Reduction Proxy.
+      VerifyWasLoFiModeActiveOnMainFrame(tests[i].is_data_reduction_proxy);
     }
 
     {
-      // TODO(megjablon): Can remove the cases below once
-      // WasLoFiModeActiveOnMainFrame is fixed to be per-page.
       // Main frame request with Lo-Fi off. Lo-Fi should not be used.
       // State of Lo-Fi should persist until next page load.
       net::HttpRequestHeaders headers;
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME);
       lofi_decider()->SetIsUsingLoFiMode(false);
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(false, headers);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy, false, headers);
       VerifyWasLoFiModeActiveOnMainFrame(false);
     }
 
     {
       // Lo-Fi is off. Lo-Fi is still not used.
       net::HttpRequestHeaders headers;
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
       lofi_decider()->SetIsUsingLoFiMode(false);
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(false, headers);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy, false, headers);
       // Not a mainframe request, WasLoFiModeActiveOnMainFrame should still be
       // false.
       VerifyWasLoFiModeActiveOnMainFrame(false);
     }
 
     {
       // Main frame request. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
       std::unique_ptr<net::URLRequest> fake_request(FetchURLRequest(
           GURL("http://www.google.com/"), nullptr, std::string(), 0));
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME);
       lofi_decider()->SetIsUsingLoFiMode(
           config()->ShouldEnableLoFiMode(*fake_request.get()));
       network_delegate()->NotifyBeforeSendProxyHeaders(
           fake_request.get(), data_reduction_proxy_info, &headers);
-      VerifyLoFiHeader(true, headers);
-      VerifyWasLoFiModeActiveOnMainFrame(true);
+      VerifyLoFiHeader(tests[i].is_data_reduction_proxy,
+                       tests[i].is_data_reduction_proxy, headers);
+      VerifyWasLoFiModeActiveOnMainFrame(tests[i].is_data_reduction_proxy);
     }
   }
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, NetHistograms) {
   const std::string kReceivedValidOCLHistogramName =
       "Net.HttpContentLengthWithValidOCL";
   const std::string kOriginalValidOCLHistogramName =
       "Net.HttpOriginalContentLengthWithValidOCL";
   const std::string kDifferenceValidOCLHistogramName =
@@ skipping 240 matching lines @@
   FetchURLRequest(GURL("http://www.google.com/"), nullptr, response_headers,
                   140);
 
   histogram_tester.ExpectBucketCount(kLoFiTransformationTypeHistogram, PREVIEW,
                                      1);
 }
 
 }  // namespace
 
 }  // namespace data_reduction_proxy