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 71 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::PRERENDERING_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 230 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::PRERENDERING_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::PRERENDERING_CANCELED,
+            last_offlining_status());
 }
 
 TEST_F(RequestCoordinatorTest, PrerendererTimeout) {
   // Build a request to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request(
       kRequestId, kUrl, kClientId, base::Time::Now());
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
@@ skipping 23 matching lines @@
   AdvanceClockBy(base::TimeDelta::FromSeconds(kTestTimeoutSeconds + 1));
   PumpLoop();
 
   // Wait for timeout to expire.  Use a TaskRunner with a DelayedTaskRunner
   // which won't time out immediately, so the watchdog thread doesn't kill valid
   // tasks too soon.
   WaitForCallback();
   PumpLoop();
 
   // Now trying to start processing on another request should return false.
-  EXPECT_EQ(Offliner::RequestStatus::CANCELED, last_offlining_status());
+  EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
+            last_offlining_status());
 }
 
 }  // namespace offline_pages