[Offline Pages] Improve RequestCoordinator state tracking.

components/offline_pages/core/background/request_coordinator.h

 // 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.
 
 #ifndef COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_REQUEST_COORDINATOR_H_
 #define COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_REQUEST_COORDINATOR_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 44 matching lines @@
     virtual void OnChanged(const SavePageRequest& request) = 0;
     virtual void OnNetworkProgress(const SavePageRequest& request,
                                    int64_t received_bytes) = 0;
   };
 
   enum class RequestAvailability {
     ENABLED_FOR_OFFLINER,
     DISABLED_FOR_OFFLINER,
   };
 
+  enum class RequestCoordinatorState {
+    IDLE,
+    STARTING,

[Pete Williamson, 2017/03/28 00:35:13]

PICKING might be more descriptive than STARTING.

[romax, 2017/03/28 01:09:56]

Done.

+    OFFLINING,
+  };
+
   // Describes the parameters to control how to save a page when system
   // conditions allow.
   struct SavePageLaterParams {
     SavePageLaterParams();
     SavePageLaterParams(const SavePageLaterParams& other);
 
     // The last committed URL of the page to save.
     GURL url;
 
     // The identification used by the client.
@@ skipping 122 matching lines @@
 
   OfflinerPolicy* policy() { return policy_.get(); }
 
   ClientPolicyController* GetPolicyController();
 
   // Returns the status of the most recent offlining.
   Offliner::RequestStatus last_offlining_status() {
     return last_offlining_status_;
   }
 
-  bool is_busy() { return is_busy_; }
-
-  // Returns whether processing is starting (before it is decided to actually
-  // process a request (is_busy()) at this time or not.
-  bool is_starting() { return is_starting_; }
+  // Return the state of the request coordinator.
+  RequestCoordinatorState state() { return state_; }
 
   // Tracks whether the last offlining attempt got canceled.  This is reset by
   // the next call to start processing.
   bool is_canceled() {
     return processing_state_ == ProcessingWindowState::STOPPED;
   }
 
   RequestCoordinatorEventLogger* GetLogger() { return &event_logger_; }
 
  private:
@@ skipping 108 matching lines @@
                      size_t total_requests,
                      size_t available_requests);
 
   void HandleWatchdogTimeout();
 
   // Cancels an in progress pre-rendering, and updates state appropriately.
   void StopPrerendering(const Offliner::CancelCallback& callback,
                         Offliner::RequestStatus stop_status);
 
   // Marks attempt on the request and sends it to offliner in continuation.
-  void SendRequestToOffliner(const SavePageRequest& request);
+  // If it fails to send request to offliner, return false.
+  bool SendRequestToOffliner(const SavePageRequest& request);
 
   // Continuation of |SendRequestToOffliner| after the request is marked as
   // started.
   void StartOffliner(int64_t request_id,
                      const std::string& client_namespace,
                      std::unique_ptr<UpdateRequestsResult> update_result);
 
   // Called by the offliner when an offlining request is completed. (and by
   // tests).
   void OfflinerDoneCallback(const SavePageRequest& request,
@@ skipping 48 matching lines @@
   }
 
   // KeyedService implementation:
   void Shutdown() override;
 
   friend class RequestCoordinatorTest;
 
   // Cached value of whether low end device. Overwritable for testing.
   bool is_low_end_device_;
 
-  // The offliner can only handle one request at a time - if the offliner is
-  // busy, prevent other requests.  This flag marks whether the offliner is in
-  // use.
-  bool is_busy_;
-  // There is more than one path to start processing so this flag is used
-  // to avoid race conditions before is_busy_ is established.
-  bool is_starting_;
+  // Current state of the request coordinator.
+  RequestCoordinatorState state_;
   // Identifies the type of current processing window or if processing stopped.
   ProcessingWindowState processing_state_;
   // True if we should use the test device conditions instead of actual
   // conditions.
   bool use_test_device_conditions_;
   // For use by tests, a fake network connection type
   net::NetworkChangeNotifier::ConnectionType test_connection_type_;
   // Owned pointer to the current offliner.
   std::unique_ptr<Offliner> offliner_;
   base::Time operation_start_time_;
@@ skipping 46 matching lines @@
   std::deque<int64_t> prioritized_requests_;
   // Allows us to pass a weak pointer to callbacks.
   base::WeakPtrFactory<RequestCoordinator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestCoordinator);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_REQUEST_COORDINATOR_H_