chrome.experimental.downloads

chrome/browser/download/download_item.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 103 matching lines @@
   }
   return dangerous_file ?
       DownloadItem::DANGEROUS_FILE : DownloadItem::NOT_DANGEROUS;
 }
 
 }  // namespace
 
 // Constructor for reading from the history service.
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const DownloadHistoryInfo& info)
-    : download_id_(-1),
+    : download_id_(info.id),
+      is_in_history_(true),
       full_path_(info.path),
       url_chain_(1, info.url),
       referrer_url_(info.referrer_url),
       total_bytes_(info.total_bytes),
       received_bytes_(info.received_bytes),
       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),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       is_otr_(false),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true) {
   if (IsInProgress())
     state_ = CANCELLED;
   if (IsComplete())
     all_data_saved_ = true;
   Init(false /* not actively downloading */);
 }
 
 // Constructing for a regular download:
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const DownloadCreateInfo& info,
                            bool is_otr)
     : state_info_(info.original_name, info.save_info.file_path,
                   info.has_user_gesture, info.prompt_user_for_save_location,
                   info.path_uniquifier, false, false,
                   info.is_extension_install),
       request_handle_(info.request_handle),
       download_id_(info.download_id),
+      is_in_history_(false),
       full_path_(info.path),
       url_chain_(info.url_chain),
       referrer_url_(info.referrer_url),
       content_disposition_(info.content_disposition),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       referrer_charset_(info.referrer_charset),
       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),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       is_otr_(is_otr),
       is_temporary_(!info.save_info.file_path.empty()),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true) {
   Init(true /* actively downloading */);
 }
 
 // Constructing for the "Save Page As..." feature:
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const FilePath& path,
                            const GURL& url,
                            bool is_otr)
-    : download_id_(1),
+    : download_id_(-1/*TODO(benjhayden) XXX*/),
+      is_in_history_(false),
       full_path_(path),
       url_chain_(1, url),
       referrer_url_(GURL()),
       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),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       is_otr_(is_otr),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(false),
@@ skipping 317 matching lines @@
 
 void DownloadItem::Remove() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   download_manager_->AssertQueueStateConsistent(this);
   Cancel(true);
   download_manager_->AssertQueueStateConsistent(this);
 
   state_ = REMOVING;
-  download_manager_->RemoveDownload(db_handle_);
+  download_manager_->RemoveDownload(id());
   // We have now been deleted.
 }
 
 bool DownloadItem::TimeRemaining(base::TimeDelta* remaining) const {
   if (total_bytes_ <= 0)
     return false;  // We never received the content_length for this download.
 
   int64 speed = CurrentSpeed();
   if (speed == 0)
     return false;
@@ skipping 42 matching lines @@
     request_handle_.ResumeRequest();
   else
     request_handle_.PauseRequest();
   is_paused_ = !is_paused_;
   UpdateObservers();
 }
 
 void DownloadItem::OnDownloadCompleting(DownloadFileManager* file_manager) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  VLOG(20) << __FUNCTION__ << "()"
+  DVLOG(1) << __FUNCTION__ << "()"
            << " needs rename = " << NeedsRename()
            << " " << DebugString(true);
   DCHECK_NE(DANGEROUS, safety_state());
   DCHECK(file_manager);
 
   if (NeedsRename()) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(file_manager,
             &DownloadFileManager::RenameCompletingDownloadFile, id(),
             GetTargetFilePath(), safety_state() == SAFE));
     return;
   }
 
   DCHECK(!is_extension_install());
   Completed();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(file_manager, &DownloadFileManager::CompleteDownload,
                         id()));
 }
 
 void DownloadItem::OnDownloadRenamedToFinalName(const FilePath& full_path) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  VLOG(20) << __FUNCTION__ << "()"
+  DVLOG(1) << __FUNCTION__ << "()"
            << " full_path = \"" << full_path.value() << "\""
            << " needed rename = " << NeedsRename()
            << " " << DebugString(false);
   DCHECK(NeedsRename());
 
   Rename(full_path);
 
   if (is_extension_install()) {
     StartCrxInstall();
     // Completed() will be called when the installer finishes.
     return;
   }
 
   Completed();
+  DVLOG(1) << DebugString(true);
 }
 
 bool DownloadItem::MatchesQuery(const string16& query) const {
   if (query.empty())
     return true;
 
   DCHECK_EQ(query, base::i18n::ToLower(query));
 
   string16 url_raw(base::i18n::ToLower(UTF8ToUTF16(GetURL().spec())));
   if (url_raw.find(query) != string16::npos)
@@ skipping 67 matching lines @@
 }
 
 DownloadHistoryInfo DownloadItem::GetHistoryInfo() const {
   return DownloadHistoryInfo(full_path(),
                              GetURL(),
                              referrer_url(),
                              start_time(),
                              received_bytes(),
                              total_bytes(),
                              state(),
-                             db_handle());
+                             id());
 }
 
 FilePath DownloadItem::GetTargetFilePath() const {
   return full_path_.DirName().Append(state_info_.target_name);
 }
 
 FilePath DownloadItem::GetFileNameToReportUser() const {
   if (state_info_.path_uniquifier > 0) {
     FilePath name(state_info_.target_name);
     download_util::AppendNumberToPath(&name, state_info_.path_uniquifier);
@@ skipping 35 matching lines @@
 }
 
 bool DownloadItem::IsInterrupted() const {
   return (state_ == INTERRUPTED);
 }
 
 bool DownloadItem::IsComplete() const {
   return (state_ == COMPLETE);
 }
 
+bool DownloadItem::IsInHistory() const {
+  return is_in_history_;
+}
+
 const GURL& DownloadItem::GetURL() const {
   return url_chain_.empty() ?
              GURL::EmptyGURL() : url_chain_.back();
 }
 
 std::string DownloadItem::DebugString(bool verbose) const {
   std::string description =
       base::StringPrintf("{ id = %d"
                          " state = %s",
-                         download_id_,
+                         id(),
                          DebugDownloadStateString(state()));
 
   // Construct a string of the URL chain.
   std::string url_list("<none>");
   if (!url_chain_.empty()) {
     std::vector<GURL>::const_iterator iter = url_chain_.begin();
     std::vector<GURL>::const_iterator last = url_chain_.end();
     url_list = (*iter).spec();
     ++iter;
     for ( ; verbose && (iter != last); ++iter) {
       url_list += " ->\n\t";
       const GURL& next_url = *iter;
       url_list += next_url.spec();
     }
   }
 
   if (verbose) {
     description += base::StringPrintf(
-        " db_handle = %" PRId64
         " total_bytes = %" PRId64
         " received_bytes = %" PRId64
         " is_paused = %c"
         " is_extension_install = %c"
         " is_otr = %c"
         " safety_state = %s"
         " url_chain = \n\t\"%s\"\n\t"
         " target_name = \"%" PRFilePath "\""
         " full_path = \"%" PRFilePath "\"",
-        db_handle(),
         total_bytes(),
         received_bytes(),
         is_paused() ? 'T' : 'F',
         is_extension_install() ? 'T' : 'F',
         is_otr() ? 'T' : 'F',
         DebugSafetyStateString(safety_state()),
         url_list.c_str(),
         state_info_.target_name.value().c_str(),
         full_path().value().c_str());
   } else {
     description += base::StringPrintf(" url = \"%s\"", url_list.c_str());
   }
 
   description += " }";
 
   return description;
 }