Adds UMA for PrerenderingOffliner request processing result status.

chrome/browser/android/offline_pages/prerendering_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/android/offline_pages/prerendering_offliner.h"
 
 #include "base/bind.h"
+#include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 
 namespace offline_pages {
 
+namespace {
+
+void RecordStatusUma(Offliner::RequestStatus request_status) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "OfflinePages.Background.OfflinerStatus",
+      static_cast<int>(request_status),
+      static_cast<int>(Offliner::RequestStatus::STATUS_COUNT));
+}
+
+}  // namespace
+
 PrerenderingOffliner::PrerenderingOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       offline_page_model_(offline_page_model),
       pending_request_(nullptr),
       weak_ptr_factory_(this) {}
 
 PrerenderingOffliner::~PrerenderingOffliner() {}
@@ skipping 33 matching lines @@
     // same as LastCommittedURL from the snapshot.
     // TODO(dougarnett): Raise issue of how to better deal with redirects.
     SavePage(web_contents->GetLastCommittedURL(), request.client_id(),
              std::move(archiver),
              base::Bind(&PrerenderingOffliner::OnSavePageDone,
                         weak_ptr_factory_.GetWeakPtr(), request,
                         completion_callback));
   } else {
     // Clear pending request and then run the completion callback.
     pending_request_.reset(nullptr);
+    RecordStatusUma(load_status);
     completion_callback.Run(request, load_status);
   }
 }
 
 void PrerenderingOffliner::OnSavePageDone(
     const SavePageRequest& request,
     const CompletionCallback& completion_callback,
     SavePageResult save_result,
     int64_t offline_id) {
   // Check if request is still pending receiving a callback.
@@ skipping 11 matching lines @@
   pending_request_.reset(nullptr);
   GetOrCreateLoader()->StopLoading();
 
   // Determine status and run the completion callback.
   Offliner::RequestStatus save_status;
   if (save_result == SavePageResult::SUCCESS) {
     save_status = RequestStatus::SAVED;
   } else {
     // TODO(dougarnett): Consider reflecting some recommendation to retry the
     // request based on specific save error cases.
-    save_status = RequestStatus::FAILED_SAVE;
+    save_status = RequestStatus::SAVE_FAILED;
   }
+  RecordStatusUma(save_status);
   completion_callback.Run(request, save_status);
 }
 
 bool PrerenderingOffliner::LoadAndSave(const SavePageRequest& request,
                                        const CompletionCallback& callback) {
   if (pending_request_) {
     DVLOG(1) << "Already have pending request";
     return false;
   }
 
@@ skipping 19 matching lines @@
     pending_request_.reset(nullptr);
 
   return accepted;
 }
 
 void PrerenderingOffliner::Cancel() {
   if (pending_request_) {
     pending_request_.reset(nullptr);
     GetOrCreateLoader()->StopLoading();
     // TODO(dougarnett): Consider ability to cancel SavePage request.
+    RecordStatusUma(Offliner::RequestStatus::REQUEST_CANCELED);
   }
 }
 
 void PrerenderingOffliner::SetLoaderForTesting(
     std::unique_ptr<PrerenderingLoader> loader) {
   DCHECK(!loader_);
   loader_ = std::move(loader);
 }
 
 void PrerenderingOffliner::SavePage(
     const GURL& url,
     const ClientId& client_id,
     std::unique_ptr<OfflinePageArchiver> archiver,
     const SavePageCallback& callback) {
   DCHECK(offline_page_model_);
   offline_page_model_->SavePage(url, client_id, std::move(archiver), callback);
 }
 
 PrerenderingLoader* PrerenderingOffliner::GetOrCreateLoader() {
   if (!loader_) {
     loader_.reset(new PrerenderingLoader(browser_context_));
   }
   return loader_.get();
 }
 
 }  // namespace offline_pages