Preliminary work on resuming downloads whose connections have expired.

chrome/browser/download/download_item.h

 // Copyright (c) 2010 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.
 //
 // Each download is represented by a DownloadItem, and all DownloadItems
 // are owned by the DownloadManager which maintains a global list of all
 // downloads. DownloadItems are created when a user initiates a download,
 // and exist for the duration of the browser life time.
 //
 // Download observers:
@@ skipping 21 matching lines @@
 
 // One DownloadItem per download. This is the model class that stores all the
 // state for a download. Multiple views, such as a tab's download shelf and the
 // Destination tab's download view, may refer to a given DownloadItem.
 class DownloadItem {
  public:
   enum DownloadState {
     IN_PROGRESS,
     COMPLETE,
     CANCELLED,
-    REMOVING
+    REMOVING,
+    INTERRUPTED
   };
 
   enum SafetyState {
     SAFE = 0,
     DANGEROUS,
     DANGEROUS_BUT_VALIDATED  // Dangerous but the user confirmed the download.
   };
 
   // Interface that observers of a particular download must implement in order
   // to receive updates to the download's status.
   class Observer {
    public:
     virtual void OnDownloadUpdated(DownloadItem* download) = 0;
 
     // Called when a downloaded file has been completed.
     virtual void OnDownloadFileCompleted(DownloadItem* download) = 0;
 
     // Called when a downloaded file has been opened.
     virtual void OnDownloadOpened(DownloadItem* download) = 0;
 
+    // Called when a downloaded file has been interrupted (had an error).
+    virtual void OnDownloadInterrupted(DownloadItem* download) = 0;
+
    protected:
     virtual ~Observer() {}
   };
 
   // Constructing from persistent store:
   DownloadItem(DownloadManager* download_manager,
                const DownloadCreateInfo& info);
 
   // Constructing for a regular download:
   DownloadItem(DownloadManager* download_manager,
@@ skipping 52 matching lines @@
   // when resuming a download (assuming the server supports byte ranges).
   void Cancel(bool update_history);
 
   // Called when all data has been saved.
   void OnAllDataSaved(int64 size);
 
   // Called when the entire download operation (including renaming etc)
   // is finished.
   void Finished();
 
+  // Download operation had an error.
+  // |size| is the amount of data received so far, and |os_error| is the error
+  // code that the operation received.
+  void Interrupted(int64 size, int os_error);
+
+  // User has resumed a download after an interruption.
+  // |new_request_id| is the new request ID associated with the download.
+  void Resumed(int new_request_id);
+
   // The user wants to remove the download from the views and history. If
   // |delete_file| is true, the file is deleted on the disk.
   void Remove(bool delete_file);
 
   // Simple calculation of the amount of time remaining to completion. Fills
   // |*remaining| with the amount of time remaining if successful. Fails and
   // returns false if we do not have the number of bytes or the speed so can
   // not estimate.
   bool TimeRemaining(base::TimeDelta* remaining) const;
 
@@ skipping 10 matching lines @@
 
   // Allow the user to temporarily pause a download or resume a paused download.
   void TogglePause();
 
   // Called when the name of the download is finalized.
   void OnNameFinalized();
 
   // Returns true if this item matches |query|. |query| must be lower-cased.
   bool MatchesQuery(const string16& query) const;
 
+  bool IsPartialDownload() const;
+  bool IsInterruptedDownload() const;
+
   // Accessors
   DownloadState state() const { return state_; }
   FilePath full_path() const { return full_path_; }
   void set_path_uniquifier(int uniquifier) { path_uniquifier_ = uniquifier; }
   GURL url() const { return url_; }
   GURL referrer_url() const { return referrer_url_; }
   std::string mime_type() const { return mime_type_; }
   std::string original_mime_type() const { return original_mime_type_; }
   int64 total_bytes() const { return total_bytes_; }
   void set_total_bytes(int64 total_bytes) { total_bytes_ = total_bytes; }
   int64 received_bytes() const { return received_bytes_; }
+  int last_os_error() const { return last_os_error_; }
   int32 id() const { return id_; }
   base::Time start_time() const { return start_time_; }
   void set_db_handle(int64 handle) { db_handle_ = handle; }
   int64 db_handle() const { return db_handle_; }
   bool is_paused() const { return is_paused_; }
   bool open_when_complete() const { return open_when_complete_; }
   void set_open_when_complete(bool open) { open_when_complete_ = open; }
   int render_process_id() const { return render_process_id_; }
   int request_id() const { return request_id_; }
   SafetyState safety_state() const { return safety_state_; }
@@ skipping 54 matching lines @@
   // The value of the content type header received when downloading
   // this item.  |mime_type_| may be different because of type sniffing.
   std::string original_mime_type_;
 
   // Total bytes expected
   int64 total_bytes_;
 
   // Current received bytes
   int64 received_bytes_;
 
+  // Last error.
+  int last_os_error_;
+
   // Start time for calculating remaining time
   base::TimeTicks start_tick_;
 
   // The current state of this download
   DownloadState state_;
 
   // The views of this item in the download shelf and download tab
   ObserverList<Observer> observers_;
 
   // Time the download was started
@@ skipping 52 matching lines @@
   // Did the user open the item either directly or indirectly (such as by
   // setting always open files of this type)? The shelf also sets this field
   // when the user closes the shelf before the item has been opened but should
   // be treated as though the user opened it.
   bool opened_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_