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 {
+// TODO(dougarnett/petewil): Move to Policy object. Also consider lower minimum
+// battery percentage once there is some processing time limits in place.
+const Scheduler::TriggerConditions kUserRequestTriggerConditions(
+    false /* require_power_connected */,
+    50 /* minimum_battery_percentage */,
+    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(GetTriggerConditionsForUserRequest());
 }
 
 // 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 28 matching lines @@
   picker_->ChooseNextRequest(
       base::Bind(&RequestCoordinator::RequestPicked,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&RequestCoordinator::RequestQueueEmpty,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RequestCoordinator::StopProcessing() {
 }
 
+Scheduler::TriggerConditions const&
+RequestCoordinator::GetTriggerConditionsForUserRequest() {
+  return kUserRequestTriggerConditions;
+}
+
 void RequestCoordinator::SendRequestToOffliner(const SavePageRequest& request) {
   // TODO(petewil): Ensure only one offliner at a time is used.
   // TODO(petewil): When we have multiple offliners, we need to pick one.
   Offliner* offliner = factory_->GetOffliner(policy_.get());
   if (!offliner) {
     DVLOG(0) << "Unable to create Offliner. "
              << "Cannot background offline page.";
     return;
   }
 
@@ skipping 18 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