Adds UMA for PrerenderingOffliner request processing result status.

components/offline_pages/background/request_coordinator_unittest.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/background/request_coordinator.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 66 matching lines @@
           base::Bind(callback, request, Offliner::RequestStatus::SAVED));
     }
     return true;
   }
 
   // Clears the currently processing request, if any.  Must have called
   // LoadAndSave first to set the callback and request.
   // Clears the currently processing request, if any.
   void Cancel() override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(callback_, request_, Offliner::RequestStatus::CANCELED));
+        FROM_HERE, base::Bind(callback_, request_,
+                              Offliner::RequestStatus::LOAD_CANCELED));
   }
 
   void enable_callback(bool enable) {
     enable_callback_ = enable;
   }
 
  private:
   CompletionCallback callback_;
   SavePageRequest request_;
   bool enable_callback_;
 };
 
 class OfflinerFactoryStub : public OfflinerFactory {
  public:
-
   OfflinerFactoryStub() : offliner_(nullptr) {}
 
   Offliner* GetOffliner(const OfflinerPolicy* policy) override {
     if (offliner_.get() == nullptr) {
       offliner_.reset(new OfflinerStub());
     }
     return offliner_.get();
   }
 
  private:
@@ skipping 11 matching lines @@
   void PumpLoop();
 
   RequestCoordinator* coordinator() {
     return coordinator_.get();
   }
 
   bool is_busy() {
     return coordinator_->is_busy();
   }
 
-  void SendRequestToOffliner(SavePageRequest& request) {
+  void SendRequestToOffliner(const SavePageRequest& request) {
     coordinator_->SendRequestToOffliner(request);
   }
 
   // Empty callback function
   void EmptyCallbackFunction(bool result) {
   }
 
   // Callback for Add requests
   void AddRequestDone(RequestQueue::AddRequestResult result,
                       const SavePageRequest& request);
@@ skipping 182 matching lines @@
   // We need to give a callback to the request.
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   EnableOfflinerCallback(true);
-  SendOfflinerDoneCallback(request, Offliner::RequestStatus::FAILED);
+  SendOfflinerDoneCallback(request, Offliner::RequestStatus::LOAD_FAILED);
   PumpLoop();
 
   // Verify the request is not removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // Still one request in the queue.
   EXPECT_EQ(1UL, last_requests().size());
@@ skipping 57 matching lines @@
   PumpLoop();
 
   // Now we cancel it while the prerenderer is busy.
   coordinator()->StopProcessing();
 
   // Let the async callbacks in the cancel run.
   PumpLoop();
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
   // Since we cancelled the event before it called offliner_->LoadAndSave().
-  EXPECT_EQ(Offliner::RequestStatus::CANCELED, last_offlining_status());
+  EXPECT_EQ(Offliner::RequestStatus::LOAD_CANCELED, last_offlining_status());
 }
 
 }  // namespace offline_pages