[Offline Pages] Close race condition of multiple StartProcessing callers.

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 172 matching lines @@
   void PumpLoop();
 
   RequestCoordinator* coordinator() {
     return coordinator_.get();
   }
 
   bool is_busy() {
     return coordinator_->is_busy();
   }
 
+  bool is_starting() { return coordinator_->is_starting(); }
+
   // 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.
@@ skipping 387 matching lines @@
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedNonUserRequestedItemsRemain) {
   // Call start processing just to set up a scheduler callback.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
   coordinator()->StartProcessing(device_conditions, callback);
+  EXPECT_TRUE(is_starting());
 
   // Call RequestNotPicked, and make sure we pick schedule a task for non user
   // requested conditions.
   CallRequestNotPicked(true);
   PumpLoop();
 
+  EXPECT_FALSE(is_starting());
+
   // The scheduler should have been called to schedule the non-user requested
   // task.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
   const Scheduler::TriggerConditions* conditions = scheduler_stub->conditions();
   EXPECT_EQ(conditions->require_power_connected,
             coordinator()->policy()->PowerRequired(!kUserRequested));
   EXPECT_EQ(
@@ skipping 48 matching lines @@
                  base::Unretained(this)));
   PumpLoop();
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(is_starting());
 
   // 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();
 
+  EXPECT_FALSE(is_starting());
+
   // OfflinerDoneCallback will not end up getting called with status SAVED,
   // 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.
@@ skipping 10 matching lines @@
   // Ensure the start processing request stops before the completion callback.
   EnableOfflinerCallback(false);
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(is_starting());
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
 
   // Coordinator should now be busy.
   EXPECT_TRUE(is_busy());
+  EXPECT_FALSE(is_starting());
 
   // Now we cancel it while the prerenderer is busy.
   coordinator()->StopProcessing();
 
   // Let the async callbacks in the cancel run.
   PumpLoop();
 
   EXPECT_FALSE(is_busy());
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
@@ skipping 74 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();
 
+  EXPECT_FALSE(is_starting());
   EXPECT_TRUE(OfflinerWasCanceled());
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 }
 
 TEST_F(RequestCoordinatorTest, TimeBudgetExceeded) {
   // Build two requests to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request1(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   offline_pages::SavePageRequest request2(
@@ skipping 172 matching lines @@
       net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
 
   // Resume the request while connected.
   coordinator()->ResumeRequests(request_ids);
   EXPECT_FALSE(is_busy());
   PumpLoop();
   EXPECT_TRUE(is_busy());
 }
 
 }  // namespace offline_pages