[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,
+    PICKING,
+    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 177 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_