Preliminary work on resuming downloads whose connections have expired.

chrome/browser/download/download_item.cc

 // 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.
 
 #include "chrome/browser/download/download_item.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/timer.h"
@@ skipping 30 matching lines @@
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const DownloadCreateInfo& info)
     : id_(-1),
       full_path_(info.path),
       url_(info.url),
       referrer_url_(info.referrer_url),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       total_bytes_(info.total_bytes),
       received_bytes_(info.received_bytes),
+      last_os_error_(0),
       start_tick_(base::TimeTicks()),
       state_(static_cast<DownloadState>(info.state)),
       start_time_(info.start_time),
       db_handle_(info.db_handle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       original_name_(info.original_name),
@@ skipping 17 matching lines @@
                            bool is_otr)
     : id_(info.download_id),
       full_path_(info.path),
       path_uniquifier_(info.path_uniquifier),
       url_(info.url),
       referrer_url_(info.referrer_url),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       total_bytes_(info.total_bytes),
       received_bytes_(0),
+      last_os_error_(0),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS),
       start_time_(info.start_time),
       db_handle_(DownloadHistory::kUninitializedHandle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       safety_state_(info.is_dangerous ? DANGEROUS : SAFE),
       auto_opened_(false),
       original_name_(info.original_name),
       render_process_id_(info.child_id),
       request_id_(info.request_id),
       save_as_(info.prompt_user_for_save_location),
       is_otr_(is_otr),
       is_extension_install_(info.is_extension_install),
       name_finalized_(false),
-      is_temporary_(!info.save_info.file_path.empty()),
+      is_temporary_(!info.save_info.file_path.empty() &&
+                    !info.is_partial_download),
       need_final_rename_(false),
       opened_(false) {
   Init(true /* start progress timer */);
 }
 
 // Constructing for the "Save Page As..." feature:
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const FilePath& path,
                            const GURL& url,
                            bool is_otr)
     : id_(1),
       full_path_(path),
       path_uniquifier_(0),
       url_(url),
       referrer_url_(GURL()),
       mime_type_(std::string()),
       original_mime_type_(std::string()),
       total_bytes_(0),
       received_bytes_(0),
+      last_os_error_(0),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS),
       start_time_(base::Time::Now()),
       db_handle_(DownloadHistory::kUninitializedHandle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       original_name_(FilePath()),
@@ skipping 45 matching lines @@
 
 void DownloadItem::OpenFilesBasedOnExtension(bool open) {
   DownloadPrefs* prefs = download_manager_->download_prefs();
   if (open)
     prefs->EnableAutoOpenBasedOnExtension(full_path());
   else
     prefs->DisableAutoOpenBasedOnExtension(full_path());
 }
 
 void DownloadItem::OpenDownload() {
-  if (state() == DownloadItem::IN_PROGRESS) {
+  if (state() == IN_PROGRESS) {
     open_when_complete_ = !open_when_complete_;
-  } else if (state() == DownloadItem::COMPLETE) {
+  } else if (state() == COMPLETE) {
     opened_ = true;
     FOR_EACH_OBSERVER(Observer, observers_, OnDownloadOpened(this));
     if (is_extension_install()) {
       download_util::OpenChromeExtension(download_manager_->profile(),
                                          download_manager_,
                                          *this);
       return;
     }
 #if defined(OS_MACOSX)
     // Mac OS X requires opening downloads on the UI thread.
@@ skipping 41 matching lines @@
 }
 
 // Updates from the download thread may have been posted while this download
 // was being cancelled in the UI thread, so we'll accept them unless we're
 // complete.
 void DownloadItem::Update(int64 bytes_so_far) {
   if (state_ == COMPLETE) {
     NOTREACHED();
     return;
   }
+  // May get called once in the INTERRUPTED state.
+  if (state_ == INTERRUPTED)
+    return;
   UpdateSize(bytes_so_far);
   UpdateObservers();
 }
 
 // Triggered by a user action.
 void DownloadItem::Cancel(bool update_history) {
-  if (state_ != IN_PROGRESS) {
-    // Small downloads might be complete before this method has a chance to run.
+  if (!IsPartialDownload()) {
+    // Small downloads might be complete or interrupted before this method has
+    // a chance to run.
     return;
   }
   state_ = CANCELLED;
   UpdateObservers();
   StopProgressTimer();
   if (update_history)
     download_manager_->DownloadCancelled(id_);
 }
 
 void DownloadItem::OnAllDataSaved(int64 size) {
@@ skipping 25 matching lines @@
   UpdateObservers();
 
   // The download file is meant to be completed if both the filename is
   // finalized and the file data is downloaded. The ordering of these two
   // actions is indeterministic. Thus, if the filename is not finalized yet,
   // delay the notification.
   if (name_finalized())
     NotifyObserversDownloadFileCompleted();
 }
 
+void DownloadItem::Interrupted(int64 size, int os_error) {
+  if (state_ != IN_PROGRESS)
+    return;
+  state_ = INTERRUPTED;
+  last_os_error_ = os_error;
+  UpdateSize(size);
+  StopProgressTimer();
+}
+
+void DownloadItem::Resumed(int new_request_id) {
+  if (state_ != INTERRUPTED)
+    return;
+  state_ = IN_PROGRESS;
+  request_id_ = new_request_id;
+  StartProgressTimer();
+}
+
 void DownloadItem::Remove(bool delete_on_disk) {
   Cancel(true);
   state_ = REMOVING;
   if (delete_on_disk) {
     ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableFunction(&DeleteDownloadedFile, full_path_));
   }
   download_manager_->RemoveDownload(db_handle_);
   // We have now been deleted.
@@ skipping 25 matching lines @@
   return percent;
 }
 
 void DownloadItem::Rename(const FilePath& full_path) {
   DCHECK(!full_path.empty());
   full_path_ = full_path;
   file_name_ = full_path_.BaseName();
 }
 
 void DownloadItem::TogglePause() {
-  DCHECK(state_ == IN_PROGRESS);
-  download_manager_->PauseDownload(id_, !is_paused_);
-  is_paused_ = !is_paused_;
+  DCHECK(IsPartialDownload());
+  if (state_ == IN_PROGRESS) {
+    download_manager_->PauseDownload(id_, !is_paused_);
+    is_paused_ = !is_paused_;
+  } else {
+    download_manager_->RestartDownload(id_);
+  }
   UpdateObservers();
 }
 
 void DownloadItem::OnNameFinalized() {
   name_finalized_ = true;
 
   // The download file is meant to be completed if both the filename is
   // finalized and the file data is downloaded. The ordering of these two
   // actions is indeterministic. Thus, if we are still in downloading the
   // file, delay the notification.
@@ skipping 22 matching lines @@
   if (url_formatted.find(query) != string16::npos)
     return true;
 
   string16 path(l10n_util::ToLower(WideToUTF16(full_path_.ToWStringHack())));
   if (path.find(query) != std::wstring::npos)
     return true;
 
   return false;
 }
 
+bool DownloadItem::IsPartialDownload() const {
+  return (state_ == IN_PROGRESS) || (state_ == INTERRUPTED);
+}
+
+bool DownloadItem::IsInterruptedDownload() const {
+  return (state_ == INTERRUPTED);
+}
+
 FilePath DownloadItem::GetFileName() const {
   if (safety_state_ == DownloadItem::SAFE)
     return file_name_;
   if (path_uniquifier_ > 0) {
     FilePath name(original_name_);
     download_util::AppendNumberToPath(&name, path_uniquifier_);
     return name;
   }
   return original_name_;
 }
 
 void DownloadItem::Init(bool start_timer) {
   file_name_ = full_path_.BaseName();
   if (start_timer)
     StartProgressTimer();
 }