Adds a prerenderer watchdog timer.

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/test/test_simple_task_runner.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "components/offline_pages/background/device_conditions.h"
 #include "components/offline_pages/background/offliner.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_policy.h"
 #include "components/offline_pages/background/request_queue.h"
 #include "components/offline_pages/background/request_queue_in_memory_store.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/background/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 // put test constants here
 const GURL kUrl("http://universe.com/everything");
 const ClientId kClientId("bookmark", "42");
 const int kRequestId(1);
+const long TEST_TIMEOUT_SECONDS = 1;
+const int BATTERY_PERCENTAGE_HIGH = 75;
+const bool POWER_REQUIRED = true;

[dewittj, 2016/07/01 17:27:48]

nit:

looks like there is inconsistent naming: kFooScheme and FOO_SCHEME.  Could we
make it consistent?

[Pete Williamson, 2016/07/01 17:56:44]

Done.  Right you are, old habits creeping back in.  Renamed to kFooScheme after
a quick check of the chromium code style guide.

 }  // namespace
 
 class SchedulerStub : public Scheduler {
  public:
   SchedulerStub()
       : schedule_called_(false),
         unschedule_called_(false),
         conditions_(false, 0, false) {}
 
   void Schedule(const TriggerConditions& trigger_conditions) override {
@@ skipping 82 matching lines @@
   void PumpLoop();
 
   RequestCoordinator* coordinator() {
     return coordinator_.get();
   }
 
   bool is_busy() {
     return coordinator_->is_busy();
   }
 
-  void SendRequestToOffliner(SavePageRequest& request) {
-    coordinator_->SendRequestToOffliner(request);
-  }
-
   // Empty callback function
   void EmptyCallbackFunction(bool result) {
   }
 
+  // Callback function which releases a wait for it.
+  void WaitingCallbackFunction(bool result) {
+    waiter_.Signal();
+  }
+
   // Callback for Add requests
   void AddRequestDone(RequestQueue::AddRequestResult result,
                       const SavePageRequest& request);
 
   // Callback for getting requests.
   void GetRequestsDone(RequestQueue::GetRequestsResult result,
                        const std::vector<SavePageRequest>& requests);
 
   void SendOfflinerDoneCallback(const SavePageRequest& request,
                                 Offliner::RequestStatus status);
 
   RequestQueue::GetRequestsResult last_get_requests_result() const {
     return last_get_requests_result_;
   }
 
   const std::vector<SavePageRequest>& last_requests() const {
     return last_requests_;
   }
 
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
   }
 
+  void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
+    coordinator_->SetOfflinerTimeoutForTest(timeout);
+  }
+
+  void WaitForCallback() {
+    waiter_.Wait();
+  }
+
+  void AdvanceClockBy(base::TimeDelta delta) {
+    task_runner_->FastForwardBy(delta);
+  }
+
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
   std::vector<SavePageRequest> last_requests_;
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
+  base::WaitableEvent waiter_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
     : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
-      task_runner_(new base::TestSimpleTaskRunner),
+      task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
-      offliner_(nullptr) {}
+      offliner_(nullptr),
+      waiter_(base::WaitableEvent::ResetPolicy::MANUAL,
+              base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
 RequestCoordinatorTest::~RequestCoordinatorTest() {}
 
 void RequestCoordinatorTest::SetUp() {
   std::unique_ptr<OfflinerPolicy> policy(new OfflinerPolicy());
   std::unique_ptr<OfflinerFactory> factory(new OfflinerFactoryStub());
   // Save the offliner for use by the tests.
   offliner_ =
       reinterpret_cast<OfflinerStub*>(factory->GetOffliner(policy.get()));
   std::unique_ptr<RequestQueueInMemoryStore>
@@ skipping 215 matching lines @@
   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());
 }
 
+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)));
+  PumpLoop();
+
+  // Set up for the call to StartProcessing.
+  DeviceConditions device_conditions(
+      !POWER_REQUIRED, BATTERY_PERCENTAGE_HIGH,
+      net::NetworkChangeNotifier::CONNECTION_3G);
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::WaitingCallbackFunction,
+                 base::Unretained(this));
+
+  // Ensure that the new request does not finish - we simulate it being
+  // in progress by asking it to skip making the completion callback.
+  EnableOfflinerCallback(false);
+
+  // Ask RequestCoordinator to stop waiting for the offliner after this many
+  // seconds.
+  SetOfflinerTimeoutForTest(base::TimeDelta::FromSeconds(TEST_TIMEOUT_SECONDS));
+
+  // Sending the request to the offliner.
+  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  PumpLoop();
+
+  // Advance the mock clock far enough to cause a watchdog timeout
+  AdvanceClockBy(base::TimeDelta::FromSeconds(TEST_TIMEOUT_SECONDS + 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());
+}
+
 }  // namespace offline_pages