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"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config_test_utils.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h"
+#include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "content/public/browser/resource_request_info.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/http/http_request_headers.h"
 #include "net/proxy/proxy_info.h"
 #include "net/socket/socket_test_util.h"
 #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 {
 
-const char kChromeProxyHeader[] = "chrome-proxy";
-
 #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)
 const Client kClient = Client::CHROME_LINUX;
@@ skipping 68 matching lines @@
     base::TrimString(test_context_->config()->test_params()->DefaultOrigin(),
                      "/", &data_reduction_proxy);
     data_reduction_proxy_info.UseNamedProxy(data_reduction_proxy);
 
     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));
+    EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
     std::string header_value;
-    headers.GetHeader(kChromeProxyHeader, &header_value);
-    EXPECT_EQ(expected_lofi_used,
-              header_value.find("q=low") != std::string::npos);
+    headers.GetHeader(chrome_proxy_header(), &header_value);
+    EXPECT_EQ(
+        expected_lofi_used,
+        header_value.find(chrome_proxy_lo_fi_directive()) != std::string::npos);
+  }
+
+  static void VerifyLoFiExperimentHeader(
+      bool expected_lofi_experiment_used,
+      const net::HttpRequestHeaders& headers) {
+    EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
+    std::string header_value;
+    headers.GetHeader(chrome_proxy_header(), &header_value);
+    EXPECT_EQ(expected_lofi_experiment_used,
+              header_value.find(chrome_proxy_lo_fi_experiment_directive()) !=
+                  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},

[megjablon, 2015/11/23 20:53:55]

git cl format did this

+  };
+
+  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