Add UMA for network type at request start

components/offline_pages/core/background/request_coordinator.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 "components/offline_pages/core/background/request_coordinator.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 140 matching lines @@
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
       AddHistogramSuffix(
           client_id,
           "OfflinePages.Background.EffectiveConnectionType.SavePageLater"),
       1, net::EFFECTIVE_CONNECTION_TYPE_LAST - 1,
       net::EFFECTIVE_CONNECTION_TYPE_LAST,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(effective_connection);
 }
 
+// Record the network quality at request creation time per namespace.
+void RecordNetworkQualityAtRequestStartForFailedRequest(
+    const ClientId& client_id,
+    const net::EffectiveConnectionType effective_connection) {
+  // The histogram below is an expansion of the UMA_HISTOGRAM_ENUMERATION
+  // macro adapted to allow for a dynamically suffixed histogram name.
+  // Note: The factory creates and owns the histogram.
+  base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
+      AddHistogramSuffix(
+          client_id,
+          "OfflinePages.Background.EffectiveConnectionType.OffliningStartType"),
+      1, net::EFFECTIVE_CONNECTION_TYPE_LAST - 1,
+      net::EFFECTIVE_CONNECTION_TYPE_LAST,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram->Add(effective_connection);
+}
+
 // This should use the same algorithm as we use for OfflinePageItem, so the IDs
 // are similar.
 int64_t GenerateOfflineId() {
   return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
 }
 
 // In case we start processing from SavePageLater, we need a callback, but there
 // is nothing for it to do.
 void EmptySchedulerCallback(bool started) {}
 
@@ skipping 29 matching lines @@
     : is_low_end_device_(base::SysInfo::IsLowEndDevice()),
       state_(RequestCoordinatorState::IDLE),
       processing_state_(ProcessingWindowState::STOPPED),
       use_test_device_conditions_(false),
       offliner_(std::move(offliner)),
       policy_(std::move(policy)),
       queue_(std::move(queue)),
       scheduler_(std::move(scheduler)),
       policy_controller_(new ClientPolicyController()),
       network_quality_estimator_(network_quality_estimator),
+      network_quality_at_request_start_(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       active_request_id_(0),
       last_offlining_status_(Offliner::RequestStatus::UNKNOWN),
       scheduler_callback_(base::Bind(&EmptySchedulerCallback)),
       internal_start_processing_callback_(base::Bind(&EmptySchedulerCallback)),
       weak_ptr_factory_(this) {
   DCHECK(policy_ != nullptr);
   std::unique_ptr<CleanupTaskFactory> cleanup_factory(
       new CleanupTaskFactory(policy_.get(), this, &event_logger_));
   queue_->SetCleanupFactory(std::move(cleanup_factory));
   // If we exited with any items left in the OFFLINING state, move them back to
@@ skipping 171 matching lines @@
 void RequestCoordinator::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveRequestsCallback& callback) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
   queue_->RemoveRequests(
       request_ids,
       base::Bind(&RequestCoordinator::HandleRemovedRequestsAndCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback,
                  RequestNotifier::BackgroundSavePageResult::REMOVED));
 
-  // Record the network quality when this request is made.
+  // Record the network quality when this request is removed.
   if (network_quality_estimator_) {
     UMA_HISTOGRAM_ENUMERATION(
         "OfflinePages.Background.EffectiveConnectionType.RemoveRequests",
         network_quality_estimator_->GetEffectiveConnectionType(),
         net::EFFECTIVE_CONNECTION_TYPE_LAST);
   }
 
   if (canceled)
     TryNextRequest(!kStartOfProcessing);
 }
 
 void RequestCoordinator::PauseRequests(
     const std::vector<int64_t>& request_ids) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
 
   // Remove the paused requests from prioritized list.
   for (int64_t id : request_ids) {
     auto it = std::find(prioritized_requests_.begin(),
                         prioritized_requests_.end(), id);
     if (it != prioritized_requests_.end())
       prioritized_requests_.erase(it);
   }
 
   queue_->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::PAUSED,
       base::Bind(&RequestCoordinator::UpdateMultipleRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  // Record the network quality when this request is made.
+  // Record the network quality when this request is paused.
   if (network_quality_estimator_) {
     UMA_HISTOGRAM_ENUMERATION(
         "OfflinePages.Background.EffectiveConnectionType.PauseRequests",
         network_quality_estimator_->GetEffectiveConnectionType(),
         net::EFFECTIVE_CONNECTION_TYPE_LAST);
   }
 
   if (canceled)
     TryNextRequest(!kStartOfProcessing);
 }
 
 void RequestCoordinator::ResumeRequests(
     const std::vector<int64_t>& request_ids) {
   prioritized_requests_.insert(prioritized_requests_.end(), request_ids.begin(),
                                request_ids.end());
   queue_->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::AVAILABLE,
       base::Bind(&RequestCoordinator::UpdateMultipleRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  // Record the network quality when this request is made.
+  // Record the network quality when this request is resumed.
   if (network_quality_estimator_) {
     UMA_HISTOGRAM_ENUMERATION(
         "OfflinePages.Background.EffectiveConnectionType.ResumeRequests",
         network_quality_estimator_->GetEffectiveConnectionType(),
         net::EFFECTIVE_CONNECTION_TYPE_LAST);
   }
 
   // Schedule a task, in case there is not one scheduled.
   ScheduleAsNeeded();
 }
@@ skipping 407 matching lines @@
     DVLOG(1) << "Failed to mark attempt started: " << request_id;
     UpdateRequestResult request_result =
         update_result->store_state != StoreState::LOADED
             ? UpdateRequestResult::STORE_FAILURE
             : UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
     event_logger_.RecordUpdateRequestFailed(client_namespace, request_result);
     return;
   }
 
   active_request_id_ = request_id;
+  network_quality_at_request_start_ =
+      network_quality_estimator_->GetEffectiveConnectionType();
 
   // Start the load and save process in the offliner (Async).
   if (offliner_->LoadAndSave(
           update_result->updated_items.at(0),
           base::Bind(&RequestCoordinator::OfflinerDoneCallback,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&RequestCoordinator::OfflinerProgressCallback,
                      weak_ptr_factory_.GetWeakPtr()))) {
     base::TimeDelta timeout;
     if (processing_state_ == ProcessingWindowState::SCHEDULED_WINDOW) {
@@ skipping 46 matching lines @@
     const SavePageRequest& request,
     int64_t received_bytes) {
   DVLOG(2) << "offliner progress, received bytes: " << received_bytes;
   DCHECK(received_bytes >= 0);
   NotifyNetworkProgress(request, received_bytes);
 }
 
 void RequestCoordinator::UpdateRequestForCompletedAttempt(
     const SavePageRequest& request,
     Offliner::RequestStatus status) {
+  // If the request failed, report the connection type as of the start of the
+  // request.
+  if (status != Offliner::RequestStatus::SAVED &&
+      status != Offliner::RequestStatus::SAVED_ON_LAST_RETRY) {
+    RecordNetworkQualityAtRequestStartForFailedRequest(
+        request.client_id(), network_quality_at_request_start_);
+  }
+
   if (status == Offliner::RequestStatus::FOREGROUND_CANCELED ||
       status == Offliner::RequestStatus::LOADING_CANCELED) {
     // Update the request for the canceled attempt.
     // TODO(dougarnett): See if we can conclusively identify other attempt
     // aborted cases to treat this way (eg, for Render Process Killed).
     UpdateRequestForAbortedAttempt(request);
   } else if (status == Offliner::RequestStatus::SAVED ||
              status == Offliner::RequestStatus::SAVED_ON_LAST_RETRY) {
     // Remove the request from the queue if it succeeded.
     RemoveAttemptedRequest(request,
@@ skipping 136 matching lines @@
   event_logger_.RecordOfflinerResult(request.client_id().name_space, status,
                                      request.request_id());
   RecordOfflinerResultUMA(request.client_id(), request.creation_time(), status);
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages