Adding opt out and previews type information to DRP pingback

chrome/browser/page_load_metrics/observers/data_reduction_proxy_metrics_observer.cc

 // Copyright 2016 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 "chrome/browser/page_load_metrics/observers/data_reduction_proxy_metrics_observer.h"
 
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
@@ skipping 100 matching lines @@
 const char kBytesInflation[] = "Experimental.Bytes.Network.Inflation";
 
 }  // namespace internal
 
 DataReductionProxyMetricsObserver::DataReductionProxyMetricsObserver()
     : browser_context_(nullptr),
       num_data_reduction_proxy_resources_(0),
       num_network_resources_(0),
       original_network_bytes_(0),
       network_bytes_proxied_(0),
-      network_bytes_(0) {}
+      network_bytes_(0),
+      tab_identifier_key_(nullptr) {}
 
 DataReductionProxyMetricsObserver::~DataReductionProxyMetricsObserver() {}
 
 // Check if the NavigationData indicates anything about the DataReductionProxy.
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 DataReductionProxyMetricsObserver::OnCommit(
     content::NavigationHandle* navigation_handle) {
   // This BrowserContext is valid for the lifetime of
   // DataReductionProxyMetricsObserver. BrowserContext is always valid and
   // non-nullptr in NavigationControllerImpl, which is a member of WebContents.
   // A raw pointer to BrowserContext taken at this point will be valid until
   // after WebContent's destructor. The latest that PageLoadTracker's destructor
   // will be called is in MetricsWebContentsObserver's destrcutor, which is
   // called in WebContents destructor.
   browser_context_ = navigation_handle->GetWebContents()->GetBrowserContext();
   // As documented in content/public/browser/navigation_handle.h, this
   // NavigationData is a clone of the NavigationData instance returned from
   // ResourceDispatcherHostDelegate::GetNavigationData during commit.
   // Because ChromeResourceDispatcherHostDelegate always returns a
   // ChromeNavigationData, it is safe to static_cast here.
   ChromeNavigationData* chrome_navigation_data =
       static_cast<ChromeNavigationData*>(
           navigation_handle->GetNavigationData());
   if (!chrome_navigation_data)
     return STOP_OBSERVING;
   data_reduction_proxy::DataReductionProxyData* data =
       chrome_navigation_data->GetDataReductionProxyData();
   if (!data || !data->used_data_reduction_proxy())
     return STOP_OBSERVING;
+  tab_identifier_key_ = navigation_handle->GetWebContents();

[Charlie Harrison, 2017/04/20 14:09:00]

This makes me really nervous. Is there any evidence that this is a unique key?
Maybe you can do something with the render view routing id of the main frame +
process id?

[RyanSturm, 2017/04/20 15:37:57]

I agree this is a little odd. How about I rework this to use session_key (server
generated random key) and page_id, which is assigned to main frame requests
uniquely. I can clearkeyasync call from didfinishnavigate as well as the
destructor for the previously committed pair of IDs. That will remove any sense
of tab from the pingback client. It seems more robust as well. Both of these are
already in drpdata FYI. Wdyt?

[Charlie Harrison, 2017/04/20 16:35:06]

This approach sounds much better, though I'm not sure what you mean by
clearkeyasync?

[bengr, 2017/04/20 17:36:18]

Likewise, I'm not sure either.

[RyanSturm, 2017/04/20 20:25:44]

Done.

   data_ = data->DeepCopy();
   // DataReductionProxy page loads should only occur on HTTP navigations.
   DCHECK(!navigation_handle->GetURL().SchemeIsCryptographic());
   return CONTINUE_OBSERVING;
 }
 
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 DataReductionProxyMetricsObserver::OnStart(
     content::NavigationHandle* navigation_handle,
     const GURL& currently_committed_url,
     bool started_in_foreground) {
   if (!started_in_foreground)
     return STOP_OBSERVING;
   return CONTINUE_OBSERVING;
 }
 
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 DataReductionProxyMetricsObserver::FlushMetricsOnAppEnterBackground(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   // FlushMetricsOnAppEnterBackground is invoked on Android in cases where the
   // app is about to be backgrounded, as part of the Activity.onPause()
   // flow. After this method is invoked, Chrome may be killed without further
   // notification, so we send a pingback with data collected up to this point.
   if (info.did_commit) {
     RecordPageSizeUMA();
-    SendPingback(timing, info);
+    SendPingback(timing, info, true /* app_background_occured */);
   }
   return STOP_OBSERVING;
 }
 
 void DataReductionProxyMetricsObserver::OnComplete(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   RecordPageSizeUMA();
-  SendPingback(timing, info);
+  SendPingback(timing, info, false /* app_background_occured */);
 }
 
 void DataReductionProxyMetricsObserver::RecordPageSizeUMA() const {
   if (!data_)
     return;
 
   // If the first request didn't complete, don't record UMA.
   if (num_network_resources_ == 0)
     return;
 
@@ skipping 67 matching lines @@
     PAGE_BYTES_HISTOGRAM(GetConstHistogramWithSuffix(internal::kBytesSavings),
                          original_network_bytes_ - network_bytes_);
   } else {
     PAGE_BYTES_HISTOGRAM(GetConstHistogramWithSuffix(internal::kBytesInflation),
                          network_bytes_proxied_ - original_network_bytes_);
   }
 }
 
 void DataReductionProxyMetricsObserver::SendPingback(
     const page_load_metrics::PageLoadTiming& timing,
-    const page_load_metrics::PageLoadExtraInfo& info) {
+    const page_load_metrics::PageLoadExtraInfo& info,
+    bool app_background_occured) {

[bengr, 2017/04/20 17:36:18]

occurred!

[RyanSturm, 2017/04/20 20:25:44]

Done.

   // TODO(ryansturm): Move to OnFirstBackgroundEvent to handle some fast
   // shutdown cases. crbug.com/618072
   if (!browser_context_ || !data_)
     return;
   if (data_reduction_proxy::params::IsIncludedInHoldbackFieldTrial() ||
       data_reduction_proxy::params::IsIncludedInTamperDetectionExperiment()) {
     return;
   }
   // Only consider timing events that happened before the first background
   // event.
@@ skipping 32 matching lines @@
   if (WasStartedInForegroundOptionalEventInForeground(timing.parse_stop,
                                                       info)) {
     parse_stop = timing.parse_stop;
   }
 
   DataReductionProxyPageLoadTiming data_reduction_proxy_timing(
       timing.navigation_start, response_start, load_event_start,
       first_image_paint, first_contentful_paint,
       experimental_first_meaningful_paint,
       parse_blocked_on_script_load_duration, parse_stop, network_bytes_,
-      original_network_bytes_);
-  GetPingbackClient()->SendPingback(*data_, data_reduction_proxy_timing);
+      original_network_bytes_, app_background_occured);
+  GetPingbackClient()->SendPingback(*data_, data_reduction_proxy_timing,
+                                    tab_identifier_key_);
 }
 
 void DataReductionProxyMetricsObserver::OnDomContentLoadedEventStart(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   RECORD_FOREGROUND_HISTOGRAMS_FOR_SUFFIX(
       info, data_, timing.dom_content_loaded_event_start,
       internal::kHistogramDOMContentLoadedEventFiredSuffix);
 }
 
@@ skipping 68 matching lines @@
       timing.parse_stop.value() - timing.parse_start.value();
   RECORD_HISTOGRAMS_FOR_SUFFIX(data_, parse_duration,
                                internal::kHistogramParseDurationSuffix);
   RECORD_HISTOGRAMS_FOR_SUFFIX(
       data_, timing.parse_blocked_on_script_load_duration.value(),
       internal::kHistogramParseBlockedOnScriptLoadSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnLoadedResource(
     const page_load_metrics::ExtraRequestInfo& extra_request_info) {
+  if (extra_request_info.was_lofi_response)
+    data_->set_lofi_received(true);
   if (extra_request_info.was_cached)
     return;
   original_network_bytes_ += extra_request_info.original_network_content_length;
   network_bytes_ += extra_request_info.raw_body_bytes;
   num_network_resources_++;
   if (!extra_request_info.data_reduction_proxy_used)
     return;
   num_data_reduction_proxy_resources_++;
   network_bytes_proxied_ += extra_request_info.raw_body_bytes;
 }
 
 DataReductionProxyPingbackClient*
 DataReductionProxyMetricsObserver::GetPingbackClient() const {
   return DataReductionProxyChromeSettingsFactory::GetForBrowserContext(
              browser_context_)
       ->data_reduction_proxy_service()
       ->pingback_client();
 }
 
 }  // namespace data_reduction_proxy