Add initial Controller to DownloadService

components/download/public/download_service.h

 // Copyright 2017 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_DOWNLOAD_PUBLIC_DOWNLOAD_SERVICE_H_
 #define COMPONENTS_DOWNLOAD_PUBLIC_DOWNLOAD_SERVICE_H_
 
+#include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
+#include "components/download/public/clients.h"
 #include "components/keyed_service/core/keyed_service.h"
 
 namespace download {
 
+class Client;
 struct DownloadParams;
 struct SchedulingParams;
 
 // A service responsible for helping facilitate the scheduling and downloading
 // of file content from the web.  See |DownloadParams| for more details on the
 // types of scheduling that can be achieved and the required input parameters
 // for starting a download.  Note that DownloadServices with a valid storage
 // directory will persist the requests across restarts.  This means that any
 // feature requesting a download will have to implement a download::Client
 // interface so this class knows who to contact when a download completes after
 // a process restart.
 class DownloadService : public KeyedService {
  public:
+  // The current status of the Service.
+  enum class ServiceStatus {
+    // The service is in the process of initializing and should not be used yet.
+    // All registered Clients will be notified via
+    // Client::OnServiceInitialized() once the service is ready.
+    STARTING_UP = 0,
+
+    // The service is ready and available for use.
+    READY = 1,
+
+    // The service is unavailable.  This is typically due to an unrecoverable
+    // error on some internal component like the persistence layer.
+    UNAVAILABLE = 2,
+  };
+
+  // |clients| is a map of DownloadClient -> std::unique_ptr<Client>.  This
+  // represents all of the clients that are allowed to have requests made on
+  // their behalf.  This cannot be changed after startup.  Any existing requests
+  // no longer associated with a client will be cancelled.
   // |storage_dir| is a path to where all the local storage will be.  This will
   // hold the internal database as well as any temporary files on disk.  If this
   // is an empty path, the service will not persist any information to disk and
   // will act as an in-memory only service (this means no auto-retries after
   // restarts, no files written on completion, etc.).
   // |background_task_runner| will be used for all disk reads and writes.
   static DownloadService* Create(
+      std::unique_ptr<DownloadClientMap> clients,
       const base::FilePath& storage_dir,
       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner);
 
+  // Whether or not the DownloadService is currently available, initialized
+  // successfully, and ready to be used.
+  virtual ServiceStatus GetStatus() = 0;
+
   // Sends the download to the service.  A callback to
   // |DownloadParams::callback| will be triggered once the download has been
   // persisted and saved in the service
   virtual void StartDownload(const DownloadParams& download_params) = 0;
 
   // Allows any feature to pause or resume downloads at will.  Paused downloads
   // will not start or stop based on scheduling criteria.  They will be
   // effectively frozen.
   virtual void PauseDownload(const std::string& guid) = 0;
   virtual void ResumeDownload(const std::string& guid) = 0;
@@ skipping 11 matching lines @@
  protected:
   DownloadService() = default;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DownloadService);
 };
 
 }  // namespace download
 
 #endif  // COMPONENTS_DOWNLOAD_PUBLIC_DOWNLOAD_SERVICE_H_