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 50 matching lines @@
   TriggerConditions const* conditions() const { return &conditions_; }
 
  private:
   bool schedule_called_;
   bool unschedule_called_;
   TriggerConditions conditions_;
 };
 
 class OfflinerStub : public Offliner {
  public:
-  OfflinerStub() : request_(kRequestId, kUrl, kClientId, base::Time::Now()),
-                   enable_callback_(false) {}
+  OfflinerStub()
+      : request_(kRequestId, kUrl, kClientId, base::Time::Now()),
+        enable_callback_(false),
+        cancel_called_(false) {}
 
   bool LoadAndSave(const SavePageRequest& request,
                    const CompletionCallback& callback) override {
     callback_ = callback;
     request_ = request;
     // Post the callback on the run loop.
     if (enable_callback_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           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));
-  }
+  void Cancel() override { cancel_called_ = true; }
 
   void enable_callback(bool enable) {
     enable_callback_ = enable;
   }
 
+  bool cancel_called() { return cancel_called_; }
+
  private:
   CompletionCallback callback_;
   SavePageRequest request_;
   bool enable_callback_;
+  bool cancel_called_;
 };
 
 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 59 matching lines @@
   }
 
   void AdvanceClockBy(base::TimeDelta delta) {
     task_runner_->FastForwardBy(delta);
   }
 
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
+  bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
+
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
   std::vector<SavePageRequest> last_requests_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
 };
 
@@ skipping 151 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 20 matching lines @@
           base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
 
   // Now, quick, before it can do much (we haven't called PumpLoop), cancel it.
   coordinator()->StopProcessing();
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
-  // Since we cancelled the event before it called offliner_->LoadAndSave().
-  EXPECT_NE(Offliner::RequestStatus::SAVED, last_offlining_status());
+  // since we cancelled the event before it called offliner_->LoadAndSave().
+  EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
+            last_offlining_status());
+
+  // Since offliner was not started, it will not have seen cancel call.
+  EXPECT_FALSE(OfflinerWasCanceled());
 }
 
 // This tests a StopProcessing call after the prerenderer has been started.
 TEST_F(RequestCoordinatorTest, StartProcessingThenStopProcessingLater) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId, kUrl, kClientId, base::Time::Now());
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
@@ skipping 14 matching lines @@
   // Let all the async parts of the start processing pipeline run to completion.
   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());
+  // since we cancelled the event before the LoadAndSave completed.
+  EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
+            last_offlining_status());
+
+  // Since offliner was started, it will have seen cancel call.
+  EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 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 22 matching lines @@
   // Advance the mock clock far enough to cause a watchdog timeout
   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_TRUE(OfflinerWasCanceled());
+  EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
+            last_offlining_status());
 }
 
 }  // namespace offline_pages