Move adding Lo-Fi directives from DRPRequestOptions to ContentLoFiDecider

components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc

 // Copyright 2015 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/content/browser/content_lofi_decider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 105 matching lines @@
     data_reduction_proxy_network_delegate_->NotifyBeforeSendProxyHeaders(
         request, data_reduction_proxy_info, headers);
   }
 
   static void VerifyLoFiHeader(bool expected_lofi_used,
                                const net::HttpRequestHeaders& headers) {
     EXPECT_TRUE(headers.HasHeader(kChromeProxyHeader));
     std::string header_value;
     headers.GetHeader(kChromeProxyHeader, &header_value);
     EXPECT_EQ(expected_lofi_used,
-              header_value.find("q=low") != std::string::npos);
+              header_value.find(kLoFiHeader) != std::string::npos);
+  }
+
+  static void VerifyLoFiExperimentHeader(
+      bool expected_lofi_experiment_used,
+      const net::HttpRequestHeaders& headers) {
+    EXPECT_TRUE(headers.HasHeader(kChromeProxyHeader));
+    std::string header_value;
+    headers.GetHeader(kChromeProxyHeader, &header_value);
+    EXPECT_EQ(expected_lofi_experiment_used,
+              header_value.find(kLoFiExperimentHeader) != std::string::npos);
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   net::MockClientSocketFactory mock_socket_factory_;
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
   scoped_ptr<DataReductionProxyTestContext> test_context_;
   scoped_ptr<DataReductionProxyNetworkDelegate>
       data_reduction_proxy_network_delegate_;
@@ skipping 78 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get());
     VerifyLoFiHeader(false, headers);
   }
 }
 
+TEST_F(ContentLoFiDeciderTest, AutoLoFi) {
+  const struct {
+    bool auto_lofi_enabled_group;
+    bool auto_lofi_control_group;
+    bool network_prohibitively_slow;
+  } tests[] = {
+      {false, false, false},
+      {false, false, true},
+      {true, false, false},
+      {true, false, true},
+      {false, true, false},
+      {false, true, true},
+      // Repeat this test data to simulate user moving out of Lo-Fi control
+      // experiment.
+      {false, true, false},
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    test_context_->config()->ResetLoFiStatusForTest();
+    // Lo-Fi header is expected only if session is part of Lo-Fi enabled field
+    // trial and network is prohibitively slow.
+    bool expect_lofi_header =
+        tests[i].auto_lofi_enabled_group && tests[i].network_prohibitively_slow;
+    bool expect_lofi_experiment_header =
+        tests[i].auto_lofi_control_group && tests[i].network_prohibitively_slow;
+
+    base::FieldTrialList field_trial_list(nullptr);
+    if (tests[i].auto_lofi_enabled_group) {
+      base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
+                                             "Enabled");
+    }
+
+    if (tests[i].auto_lofi_control_group) {
+      base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
+                                             "Control");
+    }
+
+    test_context_->config()->SetNetworkProhibitivelySlow(
+        tests[i].network_prohibitively_slow);
+
+    scoped_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].network_prohibitively_slow);
+    net::HttpRequestHeaders headers;
+    NotifyBeforeSendProxyHeaders(&headers, request.get());
+
+    VerifyLoFiHeader(expect_lofi_header, headers);
+    VerifyLoFiExperimentHeader(expect_lofi_experiment_header, headers);
+  }
+}
+
+TEST_F(ContentLoFiDeciderTest, SlowConnectionsFlag) {
+  const struct {
+    bool slow_connections_flag_enabled;
+    bool network_prohibitively_slow;
+    bool auto_lofi_enabled_group;
+
+  } tests[] = {
+      {
+          false, false, false,
+      },
+      {
+          false, true, false,
+      },
+      {
+          true, false, false,
+      },
+      {
+          true, true, false,
+      },
+      {
+          false, false, true,
+      },
+      {
+          false, true, true,
+      },
+      {
+          true, false, true,
+      },
+      {
+          true, true, true,
+      },
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    test_context_->config()->ResetLoFiStatusForTest();
+    // For the purpose of this test, Lo-Fi header is expected only if LoFi Slow
+    // Connection Flag is enabled or session is part of Lo-Fi enabled field
+    // trial. For both cases, an additional condition is that network must be
+    // prohibitively slow.
+    bool expect_lofi_header = (tests[i].slow_connections_flag_enabled &&
+                               tests[i].network_prohibitively_slow) ||
+                              (!tests[i].slow_connections_flag_enabled &&
+                               tests[i].auto_lofi_enabled_group &&
+                               tests[i].network_prohibitively_slow);
+
+    std::string expected_header;
+
+    if (tests[i].slow_connections_flag_enabled) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+          switches::kDataReductionProxyLoFi,
+          switches::kDataReductionProxyLoFiValueSlowConnectionsOnly);
+    }
+
+    base::FieldTrialList field_trial_list(nullptr);
+    if (tests[i].auto_lofi_enabled_group) {
+      base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
+                                             "Enabled");
+    }
+
+    test_context_->config()->SetNetworkProhibitivelySlow(
+        tests[i].network_prohibitively_slow);
+
+    scoped_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].network_prohibitively_slow);
+    net::HttpRequestHeaders headers;
+    NotifyBeforeSendProxyHeaders(&headers, request.get());
+
+    VerifyLoFiHeader(expect_lofi_header, headers);
+  }
+}
+
 }  // namespace data_reduction_roxy