Defines TriggerConditions and plumbs up to BackgroundScheduler

components/offline_pages/background/request_coordinator.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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_policy.h"
 #include "components/offline_pages/background/request_picker.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/background/scheduler.h"
 #include "components/offline_pages/offline_page_item.h"
 
 namespace offline_pages {
 
+namespace {
+const Scheduler::TriggerConditions kUserRequestTriggerConditions(
+    false /* require_power_connected */,
+    50 /* minimum_battery_percentage */,

[Pete Williamson, 2016/06/22 20:49:11]

25 might be better than 50 here.
It might also be good to have a public symbolic constant for the 50, and put it
in the offline_pages namespace instead of the unnamed namespace.  Tests can then
refer to the constant from here instead of using a bare 50 in the test.

[dougarnett, 2016/06/22 21:52:17]

Added to the TODO comment to consider lowering it once we limit processing time.
I'm just using this value now from the constant object.

+    false /* require_unmetered_network */);
+}  // namespace
+
 RequestCoordinator::RequestCoordinator(std::unique_ptr<OfflinerPolicy> policy,
                                        std::unique_ptr<OfflinerFactory> factory,
                                        std::unique_ptr<RequestQueue> queue,
                                        std::unique_ptr<Scheduler> scheduler)
     : policy_(std::move(policy)),
       factory_(std::move(factory)),
       queue_(std::move(queue)),
       scheduler_(std::move(scheduler)),
       last_offlining_status_(Offliner::RequestStatus::UNKNOWN),
       weak_ptr_factory_(this) {
@@ skipping 25 matching lines @@
   // immediately for testing.  It should call SendRequestToOffliner()
 
   return true;
 }
 
 void RequestCoordinator::AddRequestResultCallback(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {
 
   // Inform the scheduler that we have an outstanding task.
-  // TODO(petewil): Define proper TriggerConditions and set them.
-  Scheduler::TriggerCondition conditions;
-  scheduler_->Schedule(conditions);
+  // TODO(petewil): Determine trigger conditions from policy.
+  scheduler_->Schedule(kUserRequestTriggerConditions);
 }
 
 // Called in response to updating a request in the request queue.
 void RequestCoordinator::UpdateRequestCallback(
     RequestQueue::UpdateRequestResult result) {}
 
 // Called by the request picker when a request has been picked.
 void RequestCoordinator::RequestPicked(const SavePageRequest& request) {
   // Send the request on to the offliner.
   SendRequestToOffliner(request);
@@ skipping 66 matching lines @@
                                      weak_ptr_factory_.GetWeakPtr()));
 
     // TODO(petewil): Check time budget. Return to the scheduler if we are out.
 
     // Start another request if we have time.
     TryNextRequest();
   }
 }
 
 }  // namespace offline_pages