1 files changed, 137 insertions, 39 deletions

diff --git a/chromium/components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.cc b/chromium/components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.cc
index 8bae820f90e..12d8b56770d 100644
--- a/chromium/components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.cc
+++ b/chromium/components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.cc
@@ -23,6 +23,7 @@
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_util.h"
 #include "components/data_reduction_proxy/core/common/lofi_decider.h"
 #include "net/base/load_flags.h"
+#include "net/base/mime_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/nqe/network_quality_estimator.h"
@@ -46,27 +47,31 @@ namespace {
 // |freshness_lifetime| contains information on how long the resource will be
 // fresh for and how long is the usability.
 void RecordContentLengthHistograms(bool lofi_low_header_added,
+                                   bool is_https,
+                                   bool is_video,
                                    int64_t received_content_length,
                                    int64_t original_content_length,
                                    const base::TimeDelta& freshness_lifetime) {
   // Add the current resource to these histograms only when a valid
   // X-Original-Content-Length header is present.
   if (original_content_length >= 0) {
-    UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthWithValidOCL",
-                         received_content_length);
-    UMA_HISTOGRAM_COUNTS("Net.HttpOriginalContentLengthWithValidOCL",
-                         original_content_length);
-    UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthDifferenceWithValidOCL",
-                         original_content_length - received_content_length);
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthWithValidOCL",
+                            received_content_length);
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpOriginalContentLengthWithValidOCL",
+                            original_content_length);
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthDifferenceWithValidOCL",
+                            original_content_length - received_content_length);
 
     // Populate Lo-Fi content length histograms.
     if (lofi_low_header_added) {
-      UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthWithValidOCL.LoFiOn",
-                           received_content_length);
-      UMA_HISTOGRAM_COUNTS("Net.HttpOriginalContentLengthWithValidOCL.LoFiOn",
-                           original_content_length);
-      UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthDifferenceWithValidOCL.LoFiOn",
-                           original_content_length - received_content_length);
+      UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthWithValidOCL.LoFiOn",
+                              received_content_length);
+      UMA_HISTOGRAM_COUNTS_1M(
+          "Net.HttpOriginalContentLengthWithValidOCL.LoFiOn",
+          original_content_length);
+      UMA_HISTOGRAM_COUNTS_1M(
+          "Net.HttpContentLengthDifferenceWithValidOCL.LoFiOn",
+          original_content_length - received_content_length);
     }
 
   } else {
@@ -74,11 +79,22 @@ void RecordContentLengthHistograms(bool lofi_low_header_added,
     // length if the X-Original-Content-Header is not present.
     original_content_length = received_content_length;
   }
-  UMA_HISTOGRAM_COUNTS("Net.HttpContentLength", received_content_length);
-  UMA_HISTOGRAM_COUNTS("Net.HttpOriginalContentLength",
-                       original_content_length);
-  UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthDifference",
-                       original_content_length - received_content_length);
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLength", received_content_length);
+  if (is_https) {
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLength.Https",
+                            received_content_length);
+  } else {
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLength.Http",
+                            received_content_length);
+  }
+  if (is_video) {
+    UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLength.Video",
+                            received_content_length);
+  }
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpOriginalContentLength",
+                          original_content_length);
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthDifference",
+                          original_content_length - received_content_length);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.HttpContentFreshnessLifetime",
                               freshness_lifetime.InSeconds(),
                               base::TimeDelta::FromHours(1).InSeconds(),
@@ -86,17 +102,17 @@ void RecordContentLengthHistograms(bool lofi_low_header_added,
                               100);
   if (freshness_lifetime.InSeconds() <= 0)
     return;
-  UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable",
-                       received_content_length);
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthCacheable",
+                          received_content_length);
   if (freshness_lifetime.InHours() < 4)
     return;
-  UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable4Hours",
-                       received_content_length);
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthCacheable4Hours",
+                          received_content_length);
 
   if (freshness_lifetime.InHours() < 24)
     return;
-  UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable24Hours",
-                       received_content_length);
+  UMA_HISTOGRAM_COUNTS_1M("Net.HttpContentLengthCacheable24Hours",
+                          received_content_length);
 }
 
 // Given a |request| that went through the Data Reduction Proxy, this function
@@ -113,6 +129,19 @@ int64_t EstimateOriginalReceivedBytes(const net::URLRequest& request) {
          util::CalculateEffectiveOCL(request);
 }
 
+// Verifies that the chrome proxy related request headers are set correctly.
+// |via_chrome_proxy| is true if the request is being fetched via Chrome Data
+// Saver proxy.
+void VerifyHttpRequestHeaders(bool via_chrome_proxy,
+                              const net::HttpRequestHeaders& headers) {
+  if (via_chrome_proxy) {
+    DCHECK(headers.HasHeader(chrome_proxy_header()));
+  } else {
+    DCHECK(!headers.HasHeader(chrome_proxy_header()));
+    DCHECK(!headers.HasHeader(chrome_proxy_accept_transform_header()));
+  }
+}
+
 }  // namespace
 
 DataReductionProxyNetworkDelegate::DataReductionProxyNetworkDelegate(
@@ -205,6 +234,17 @@ void DataReductionProxyNetworkDelegate::OnBeforeSendHeadersInternal(
   DCHECK(data_reduction_proxy_config_);
   DCHECK(request);
 
+  // If there was a redirect or request bypass, use the same page ID for both
+  // requests. As long as the session ID has not changed. Re-issued requests
+  // and client redirects will be assigned a new page ID as they are different
+  // URLRequests.
+  DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
+  base::Optional<uint64_t> page_id;
+  if (data && data->session_key() ==
+                  data_reduction_proxy_request_options_->GetSecureSession()) {
+    page_id = data->page_id();
+  }
+
   // Reset |request|'s DataReductionProxyData.
   DataReductionProxyData::ClearData(request);
 
@@ -212,10 +252,10 @@ void DataReductionProxyNetworkDelegate::OnBeforeSendHeadersInternal(
     if (!WasEligibleWithoutHoldback(*request, proxy_info, proxy_retry_info))
       return;
     // For the holdback field trial, still log UMA as if the proxy was used.
-    DataReductionProxyData* data =
-        DataReductionProxyData::GetDataAndCreateIfNecessary(request);
+    data = DataReductionProxyData::GetDataAndCreateIfNecessary(request);
     if (data)
       data->set_used_data_reduction_proxy(true);
+    VerifyHttpRequestHeaders(false, *headers);
     return;
   }
 
@@ -241,23 +281,26 @@ void DataReductionProxyNetworkDelegate::OnBeforeSendHeadersInternal(
       // Chrome-Proxy-Accept-Transform header.
       lofi_decider->RemoveAcceptTransformHeader(headers);
     }
+    VerifyHttpRequestHeaders(false, *headers);
     return;
   }
 
   // Retrieves DataReductionProxyData from a request, creating a new instance
   // if needed.
-  DataReductionProxyData* data =
-      DataReductionProxyData::GetDataAndCreateIfNecessary(request);
+  data = DataReductionProxyData::GetDataAndCreateIfNecessary(request);
   if (data) {
     data->set_used_data_reduction_proxy(true);
-    data->set_session_key(
-        data_reduction_proxy_request_options_->GetSecureSession());
-    data->set_request_url(request->url());
-    if ((request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) &&
-        request->context()->network_quality_estimator()) {
-      data->set_effective_connection_type(request->context()
-                                              ->network_quality_estimator()
-                                              ->GetEffectiveConnectionType());
+    // Only set GURL, NQE and session key string for main frame requests since
+    // they are not needed for sub-resources.
+    if (request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) {
+      data->set_session_key(
+          data_reduction_proxy_request_options_->GetSecureSession());
+      data->set_request_url(request->url());
+      if (request->context()->network_quality_estimator()) {
+        data->set_effective_connection_type(request->context()
+                                                ->network_quality_estimator()
+                                                ->GetEffectiveConnectionType());
+      }
     }
   }
 
@@ -274,17 +317,46 @@ void DataReductionProxyNetworkDelegate::OnBeforeSendHeadersInternal(
   }
   MaybeAddBrotliToAcceptEncodingHeader(proxy_info, headers, *request);
 
-  data_reduction_proxy_request_options_->AddRequestHeader(headers);
+  // Generate a page ID for main frame requests that don't already have one.
+  // TODO(ryansturm): remove LOAD_MAIN_FRAME_DEPRECATED from d_r_p.
+  // crbug.com/709621
+  if (request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) {
+    if (!page_id) {
+      page_id = data_reduction_proxy_request_options_->GeneratePageId();
+    }
+    data->set_page_id(page_id.value());
+  }
+
+  data_reduction_proxy_request_options_->AddRequestHeader(headers, page_id);
+
   if (lofi_decider)
     lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(headers);
+  VerifyHttpRequestHeaders(true, *headers);
 }
 
 void DataReductionProxyNetworkDelegate::OnBeforeRedirectInternal(
     net::URLRequest* request,
     const GURL& new_location) {
   // Since this is after a redirect response, reset |request|'s
-  // DataReductionProxyData.
+  // DataReductionProxyData, but keep page ID and session.
+  // TODO(ryansturm): Change ClearData logic to have persistent and
+  // non-persistent (WRT redirects) data.
+  // crbug.com/709564
+  DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
+  base::Optional<uint64_t> page_id;
+  if (data && data->session_key() ==
+                  data_reduction_proxy_request_options_->GetSecureSession()) {
+    page_id = data->page_id();
+  }
+
   DataReductionProxyData::ClearData(request);
+
+  if (page_id) {
+    data = DataReductionProxyData::GetDataAndCreateIfNecessary(request);
+    data->set_page_id(page_id.value());
+    data->set_session_key(
+        data_reduction_proxy_request_options_->GetSecureSession());
+  }
 }
 
 void DataReductionProxyNetworkDelegate::OnCompletedInternal(
@@ -338,6 +410,25 @@ void DataReductionProxyNetworkDelegate::OnCompletedInternal(
   RecordContentLength(*request, request_type, original_content_length);
 }
 
+void DataReductionProxyNetworkDelegate::OnHeadersReceivedInternal(
+    net::URLRequest* request,
+    const net::CompletionCallback& callback,
+    const net::HttpResponseHeaders* original_response_headers,
+    scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
+    GURL* allowed_unsafe_redirect_url) {
+  if (!original_response_headers)
+    return;
+  if (IsEmptyImagePreview(*original_response_headers)) {
+    DataReductionProxyData* data =
+        DataReductionProxyData::GetDataAndCreateIfNecessary(request);
+    data->set_lofi_received(true);
+  } else if (IsLitePagePreview(*original_response_headers)) {
+    DataReductionProxyData* data =
+        DataReductionProxyData::GetDataAndCreateIfNecessary(request);
+    data->set_lite_page_received(true);
+  }
+}
+
 void DataReductionProxyNetworkDelegate::CalculateAndRecordDataUsage(
     const net::URLRequest& request,
     DataReductionProxyRequestType request_type) {
@@ -395,14 +486,21 @@ void DataReductionProxyNetworkDelegate::RecordContentLength(
           ->GetFreshnessLifetimes(request.response_info().response_time)
           .freshness;
 
+  bool is_https = request.url().SchemeIs("https");
+  bool is_video = false;
+  std::string mime_type;
+  if (request.response_headers()->GetMimeType(&mime_type)) {
+    is_video = net::MatchesMimeType("video/*", mime_type);
+  }
+
   RecordContentLengthHistograms(
       // |data_reduction_proxy_io_data_| can be NULL for Webview.
       data_reduction_proxy_io_data_ &&
           data_reduction_proxy_io_data_->IsEnabled() &&
           data_reduction_proxy_io_data_->lofi_decider() &&
           data_reduction_proxy_io_data_->lofi_decider()->IsUsingLoFi(request),
-      request.received_response_content_length(), original_content_length,
-      freshness_lifetime);
+      is_https, is_video, request.received_response_content_length(),
+      original_content_length, freshness_lifetime);
 
   if (data_reduction_proxy_io_data_ && data_reduction_proxy_bypass_stats_) {
     // Record BypassedBytes histograms for the request.