Do not trigger Lo-Fi on main frame requests

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 <stddef.h>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 158 matching lines @@
   std::unique_ptr<DataReductionProxyTestContext> test_context_;
   std::unique_ptr<DataReductionProxyNetworkDelegate>
       data_reduction_proxy_network_delegate_;
 };
 
 TEST_F(ContentLoFiDeciderTest, LoFiFlags) {
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_using_previews;
+    bool is_main_frame;
   } tests[] = {
-      {false, false}, {true, false}, {false, true}, {true, true},
+      {false, false, false}, {false, false, true}, {true, false, true},
+      {true, false, false},  {false, true, false}, {false, true, true},
+      {true, true, true},    {true, true, false},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].is_using_lofi);
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->InitFromArgv(command_line->argv());
     if (tests[i].is_using_previews) {
       command_line->AppendSwitch(
           switches::kEnableDataReductionProxyLoFiPreview);
     }
 
     // No flags or field trials. The Lo-Fi header should not be added.
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
 
     // The Lo-Fi flag is "always-on", Lo-Fi is being used, and it's a main frame
     // request. Lo-Fi preview header should be added.
     command_line->AppendSwitchASCII(
         switches::kDataReductionProxyLoFi,
         switches::kDataReductionProxyLoFiValueAlwaysOn);
-    request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
+    if (tests[i].is_main_frame)
+      request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_previews,
+    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_previews &&
+                         !tests[i].is_main_frame,
                      headers);
-    VerifyLoFiPreviewHeader(
-        tests[i].is_using_lofi && tests[i].is_using_previews, headers);
-    VerifyLoFiIgnorePreviewBlacklistHeader(
-        tests[i].is_using_lofi && tests[i].is_using_previews, headers);
+    VerifyLoFiPreviewHeader(tests[i].is_using_lofi &&
+                                tests[i].is_using_previews &&
+                                tests[i].is_main_frame,
+                            headers);
+    VerifyLoFiIgnorePreviewBlacklistHeader(tests[i].is_using_lofi &&
+                                               tests[i].is_using_previews &&
+                                               tests[i].is_main_frame,
+                                           headers);
 
     // The Lo-Fi flag is "always-on" and Lo-Fi is being used. Lo-Fi header
     // should be added.
     request->SetLoadFlags(0);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_previews,
                      headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
@@ skipping 24 matching lines @@
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
-  } tests[] = {
-      {false}, {true},
-  };
+    bool is_main_frame;
+  } tests[] = {{false, false}, {false, true}, {true, false}, {true, true}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].is_using_lofi);
+    if (tests[i].is_main_frame)
+      request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi, headers);
+    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_main_frame,
+                     headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Control");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
-  } tests[] = {
-      {false}, {true},
-  };
+    bool is_main_frame;
+  } tests[] = {{false, false}, {false, true}, {true, false}, {true, true}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].is_using_lofi);
+    if (tests[i].is_main_frame)
+      request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiPreviewFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
@@ skipping 19 matching lines @@
                             headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, AutoLoFi) {
   const struct {
     bool auto_lofi_enabled_group;
     bool auto_lofi_control_group;
     bool network_prohibitively_slow;
+    bool is_main_frame;
   } tests[] = {
-      {false, false, false},
-      {false, false, true},
-      {true, false, false},
-      {true, false, true},
-      {false, true, false},
-      {false, true, true},
+      {false, false, false, false},
+      {false, false, true, false},
+      {true, false, false, false},
+      {true, false, true, false},
+      {true, false, true, true},
+      {false, true, false, false},
+      {false, true, true, false},
       // Repeat this test data to simulate user moving out of Lo-Fi control
       // experiment.
-      {false, true, false},
+      {false, true, false, 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;
+    const bool expect_lofi_header = tests[i].auto_lofi_enabled_group &&
+                                    tests[i].network_prohibitively_slow &&
+                                    !tests[i].is_main_frame;
 
     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);
 
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].network_prohibitively_slow);
+    if (tests[i].is_main_frame)
+      request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
 
     VerifyLoFiHeader(expect_lofi_header, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, SlowConnectionsFlag) {
   const struct {
     bool slow_connections_flag_enabled;
     bool network_prohibitively_slow;
     bool auto_lofi_enabled_group;
-
+    bool is_main_frame;
   } 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},
+      {false, false, false, false}, {false, true, false, false},
+      {true, false, false, false},  {true, true, false, false},
+      {true, true, false, true},    {false, false, true, false},
+      {false, false, true, true},   {false, true, true, false},
+      {true, false, true, false},   {true, true, true, false},
   };
 
   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);
+    const 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)) &&
+                                    !tests[i].is_main_frame;
 
     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);
 
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].network_prohibitively_slow);
+    if (tests[i].is_main_frame)
+      request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
 
     VerifyLoFiHeader(expect_lofi_header, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, ProxyIsNotDataReductionProxy) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
@@ skipping 11 matching lines @@
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), false);
     std::string header_value;
     headers.GetHeader(chrome_proxy_header(), &header_value);
     EXPECT_EQ(std::string::npos,
               header_value.find(chrome_proxy_lo_fi_directive()));
   }
 }
 
 }  // namespace data_reduction_roxy