Add UMA to determine how often we offline a page with previews.

chrome/browser/offline_pages/background_loader_offliner.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/offline_pages/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
+#include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
+#include "chrome/browser/loader/chrome_navigation_data.h"
 #include "chrome/browser/profiles/profile.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
 #include "components/offline_pages/core/background/offliner_policy.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/mhtml_extra_parts.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_user_data.h"
+#include "content/public/common/previews_state.h"
 
 namespace offline_pages {
 
 namespace {
 const char kContentType[] = "text/plain";
 const char kContentTransferEncodingBinary[] =
     "Content-Transfer-Encoding: binary";
 const char kXHeaderForSignals[] = "X-Chrome-Loading-Metrics-Data: 1";
 
 class OfflinerData : public content::WebContentsUserData<OfflinerData> {
@@ skipping 29 matching lines @@
   return adjusted_histogram_name;
 }
 
 void RecordErrorCauseUMA(const ClientId& client_id, net::Error error_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       AddHistogramSuffix(client_id,
                          "OfflinePages.Background.BackgroundLoadingFailedCode"),
       std::abs(error_code));
 }
 
+void RecordOffliningPreviewsUMA(const ClientId& client_id,
+                                ChromeNavigationData* navigation_data) {
+  content::PreviewsState previews_state = content::PreviewsTypes::PREVIEWS_OFF;
+  if (navigation_data)
+    previews_state = navigation_data->previews_state();
+
+  int is_previews_enabled = 0;
+  bool lite_page_received = false;
+  data_reduction_proxy::DataReductionProxyData* data_reduction_proxy_data =
+      nullptr;
+  if (navigation_data)
+    data_reduction_proxy_data = navigation_data->GetDataReductionProxyData();
+  if (data_reduction_proxy_data)
+    lite_page_received = data_reduction_proxy_data->lite_page_received();
+
+  if ((previews_state != content::PreviewsTypes::PREVIEWS_OFF &&
+       previews_state != content::PreviewsTypes::PREVIEWS_NO_TRANSFORM) ||
+      lite_page_received)
+    is_previews_enabled = 1;
+
+  base::UmaHistogramBoolean(
+      AddHistogramSuffix(client_id,
+                         "OfflinePages.Background.OffliningPreviewStatus"),
+      is_previews_enabled);
+}
+
 void HandleLoadTerminationCancel(
     const Offliner::CompletionCallback& completion_callback,
     const SavePageRequest& canceled_request) {
   completion_callback.Run(canceled_request,
                           Offliner::RequestStatus::FOREGROUND_CANCELED);
 }
 
 }  // namespace
 
 BackgroundLoaderOffliner::BackgroundLoaderOffliner(
@@ skipping 218 matching lines @@
     RecordErrorCauseUMA(pending_request_->client_id(),
                         navigation_handle->GetNetErrorCode());
     switch (navigation_handle->GetNetErrorCode()) {
       case net::ERR_INTERNET_DISCONNECTED:
         page_load_state_ = DELAY_RETRY;
         break;
       default:
         page_load_state_ = RETRIABLE;
     }
   }
+
+  // Record UMA if we are offlining a previvew instead of an unmodified page.
+  // 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* navigation_data = static_cast<ChromeNavigationData*>(
+      navigation_handle->GetNavigationData());
+
+  RecordOffliningPreviewsUMA(pending_request_->client_id(), navigation_data);
 }
 
 void BackgroundLoaderOffliner::SetSnapshotControllerForTest(
     std::unique_ptr<SnapshotController> controller) {
   snapshot_controller_ = std::move(controller);
 }
 
 void BackgroundLoaderOffliner::OnNetworkBytesChanged(int64_t bytes) {
   if (pending_request_ && save_state_ != SAVING) {
     network_bytes_ += bytes;
@@ skipping 156 matching lines @@
   // Given the choice between int and double, we choose to implicitly convert to
   // a double since it maintains more precision (we can get a longer time in
   // milliseconds than we can with a 2 bit int, 53 bits vs 32).
   double delay = delay_so_far.InMilliseconds();
   signal_data_.SetDouble(signal_name, delay);
 }
 
 }  // namespace offline_pages
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(offline_pages::OfflinerData);