Create a Lite Page bit for previews and fallback to Lo-Fi

components/data_reduction_proxy/core/browser/data_reduction_proxy_config.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/core/browser/data_reduction_proxy_config.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 940 matching lines @@
 
   accuracy_histogram->Add(accuracy);
 }
 
 bool DataReductionProxyConfig::IsEffectiveConnectionTypeSlowerThanThreshold(
     net::EffectiveConnectionType effective_connection_type) const {
   return effective_connection_type >= net::EFFECTIVE_CONNECTION_TYPE_OFFLINE &&
          effective_connection_type <= lofi_effective_connection_type_threshold_;
 }
 
-bool DataReductionProxyConfig::ShouldEnableLoFiMode(
+bool DataReductionProxyConfig::ShouldEnableLoFi(
     const net::URLRequest& request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK((request.load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) != 0);
   DCHECK(!request.url().SchemeIsCryptographic());
 
   net::NetworkQualityEstimator* network_quality_estimator;
   network_quality_estimator =
       request.context() ? request.context()->network_quality_estimator()
                         : nullptr;
 
-  bool enable_lofi = ShouldEnableLoFiModeInternal(network_quality_estimator);
+  bool enable_lofi = ShouldEnableLoFiInternal(network_quality_estimator);
 
   if (params::IsLoFiSlowConnectionsOnlyViaFlags() ||
       params::IsIncludedInLoFiEnabledFieldTrial()) {
     RecordAutoLoFiRequestHeaderStateChange(previous_state_lofi_on_,
                                            enable_lofi);
     previous_state_lofi_on_ = enable_lofi;
   }
 
   return enable_lofi;
 }
 
+bool DataReductionProxyConfig::ShouldEnableLitePages(
+    const net::URLRequest& request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK((request.load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) != 0);
+  DCHECK(!request.url().SchemeIsCryptographic());
+
+  net::NetworkQualityEstimator* network_quality_estimator;
+  network_quality_estimator =
+      request.context() ? request.context()->network_quality_estimator()
+                        : nullptr;
+
+  return ShouldEnableLitePagesInternal(network_quality_estimator);

[bengr, 2017/02/15 00:03:47]

You could get rid of the temporary:
return ShouldEnableLitePagesInternal(
    request.context() ? request.context()->network_quality_estimator() :
        nullptr);

[megjablon, 2017/02/16 04:29:09]

Done.

+}
+
 bool DataReductionProxyConfig::enabled_by_user_and_reachable() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return enabled_by_user_ && !unreachable_;
 }
 
-bool DataReductionProxyConfig::ShouldEnableLoFiModeInternal(
+bool DataReductionProxyConfig::ShouldEnableLoFiInternal(
     const net::NetworkQualityEstimator* network_quality_estimator) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   last_query_ = GetTicksNow();
   network_quality_at_last_query_ = NETWORK_QUALITY_AT_LAST_QUERY_UNKNOWN;
 
   // If Lo-Fi has been turned off, its status can't change.
   if (lofi_off_)
     return false;
 
@@ skipping 10 matching lines @@
       params::IsIncludedInLoFiControlFieldTrial()) {
     return IsNetworkQualityProhibitivelySlow(network_quality_estimator);
   }
 
   // If Lo-Fi is not enabled through command line and the user is not in
   // Lo-Fi field trials, set Lo-Fi to off.
   lofi_off_ = true;
   return false;
 }
 
+bool DataReductionProxyConfig::ShouldEnableLitePagesInternal(
+    const net::NetworkQualityEstimator* network_quality_estimator) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If Lo-Fi has been turned off, its status can't change. This Lo-Fi bit will
+  // be removed when Lo-Fi and Lite Pages are moved over to using the Previews
+  // blacklist.
+  if (lofi_off_)
+    return false;
+
+  // TODO: Move the Lo-Fi flag to a flag supporting all Previews types.

[bengr, 2017/02/15 00:03:47]

TODO(megjablon):

[megjablon, 2017/02/16 04:29:09]

Removing since we should discuss how we want the handle flags for previews
offline. We should probably just have individual ones for each preview.

+  if (params::IsLoFiAlwaysOnViaFlags() && params::AreLitePagesEnabledViaFlags())
+    return true;
+
+  if (params::IsLoFiCellularOnlyViaFlags() &&
+      params::AreLitePagesEnabledViaFlags()) {
+    return net::NetworkChangeNotifier::IsConnectionCellular(
+        net::NetworkChangeNotifier::GetConnectionType());
+  }
+
+  if ((params::IsLoFiSlowConnectionsOnlyViaFlags() &&
+       params::AreLitePagesEnabledViaFlags()) ||
+      params::IsIncludedInLitePageFieldTrial() ||
+      params::IsIncludedInLoFiControlFieldTrial()) {
+    return IsNetworkQualityProhibitivelySlow(network_quality_estimator);
+  }
+
+  return false;
+}
+
 void DataReductionProxyConfig::GetNetworkList(
     net::NetworkInterfaceList* interfaces,
     int policy) {
   net::GetNetworkList(interfaces, policy);
 }
 
 const std::vector<base::TimeDelta>&
 DataReductionProxyConfig::GetLofiAccuracyRecordingIntervals() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return lofi_accuracy_recording_intervals_;
 }
 
 base::TimeTicks DataReductionProxyConfig::GetTicksNow() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::TimeTicks::Now();
 }
 
 net::ProxyConfig DataReductionProxyConfig::ProxyConfigIgnoringHoldback() const {
   std::vector<net::ProxyServer> proxies_for_http =
       DataReductionProxyServer::ConvertToNetProxyServers(
           config_values_->proxies_for_http());
   if (!enabled_by_user_ || proxies_for_http.empty())
     return net::ProxyConfig::CreateDirect();
   return configurator_->CreateProxyConfig(!secure_proxy_allowed_,
                                           proxies_for_http);
 }
 
 }  // namespace data_reduction_proxy