Make DownloadHistory observe manager, items

content/browser/download/download_item_impl.cc

 // Copyright (c) 2012 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 "content/browser/download/download_item_impl.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/string_search.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/download_persistent_store_info.h"
 #include "net/base/net_util.h"
 
 using content::BrowserThread;
 using content::DownloadFile;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
-using content::DownloadPersistentStoreInfo;
 using content::WebContents;
 
 // A DownloadItem normally goes through the following states:
 //      * Created (when download starts)
 //      * Made visible to consumers (e.g. Javascript) after the
 //        destination file has been determined.
 //      * Entered into the history database.
 //      * Made visible in the download shelf.
 //      * All data is saved.  Note that the actual data download occurs
 //        in parallel with the above steps, but until those steps are
@@ skipping 72 matching lines @@
 
 }  // namespace
 
 namespace content {
 
 // Our download table ID starts at 1, so we use 0 to represent a download that
 // has started, but has not yet had its data persisted in the table. We use fake
 // database handles in incognito mode starting at -1 and progressively getting
 // more negative.
 // static
 const int DownloadItem::kUninitializedHandle = 0;

[Randy Smith (Not in Mondays), 2012/08/20 18:57:04]

Shouldn't this be nuked as well?

[benjhayden, 2012/08/24 15:32:15]

Done.

 
 const char DownloadItem::kEmptyFileHash[] = "";
 
 }
 
 // Our download table ID starts at 1, so we use 0 to represent a download that
 // has started, but has not yet had its data persisted in the table. We use fake
 // database handles in incognito mode starting at -1 and progressively getting
 // more negative.
 
 // Constructor for reading from the history service.
 DownloadItemImpl::DownloadItemImpl(DownloadItemImplDelegate* delegate,
                                    DownloadId download_id,
-                                   const DownloadPersistentStoreInfo& info,
+                                   const FilePath& path,
+                                   const GURL& url,
+                                   const GURL& referrer_url,
+                                   const base::Time& start_time,
+                                   const base::Time& end_time,
+                                   int64 received_bytes,
+                                   int64 total_bytes,
+                                   DownloadItem::DownloadState state,
+                                   bool opened,
                                    const net::BoundNetLog& bound_net_log)
     : download_id_(download_id),
-      current_path_(info.path),
-      target_path_(info.path),
+      current_path_(path),
+      target_path_(path),
       target_disposition_(TARGET_DISPOSITION_OVERWRITE),
-      url_chain_(1, info.url),
-      referrer_url_(info.referrer_url),
+      url_chain_(1, url),
+      referrer_url_(referrer_url),
       transition_type_(content::PAGE_TRANSITION_LINK),
       has_user_gesture_(false),
-      total_bytes_(info.total_bytes),
-      received_bytes_(info.received_bytes),
+      total_bytes_(total_bytes),
+      received_bytes_(received_bytes),
       bytes_per_sec_(0),
       last_reason_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks()),
-      state_(info.state),
+      state_(state),
       danger_type_(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
-      start_time_(info.start_time),
-      end_time_(info.end_time),
-      db_handle_(info.db_handle),
+      start_time_(start_time),
+      end_time_(end_time),
       delegate_(delegate),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
-      is_persisted_(true),
       is_temporary_(false),
       all_data_saved_(false),
-      opened_(info.opened),
+      opened_(opened),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
   if (IsInProgress())
     state_ = CANCELLED;
   if (IsComplete())
     all_data_saved_ = true;
   Init(false /* not actively downloading */,
@@ skipping 23 matching lines @@
       referrer_charset_(info.referrer_charset),
       remote_address_(info.remote_address),
       total_bytes_(info.total_bytes),
       received_bytes_(0),
       bytes_per_sec_(0),
       last_reason_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS),
       danger_type_(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
       start_time_(info.start_time),
-      db_handle_(DownloadItem::kUninitializedHandle),
       delegate_(delegate),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
-      is_persisted_(false),
       is_temporary_(!info.save_info.file_path.empty()),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
   Init(true /* actively downloading */,
        download_net_logs::SRC_NEW_DOWNLOAD);
@@ skipping 27 matching lines @@
       mime_type_(mime_type),
       original_mime_type_(mime_type),
       total_bytes_(0),
       received_bytes_(0),
       bytes_per_sec_(0),
       last_reason_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS),
       danger_type_(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
       start_time_(base::Time::Now()),
-      db_handle_(DownloadItem::kUninitializedHandle),
       delegate_(delegate),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
-      is_persisted_(false),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
   Init(true /* actively downloading */,
        download_net_logs::SRC_SAVE_PAGE_AS);
@@ skipping 523 matching lines @@
   return (danger_type_ == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE ||
           danger_type_ == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL ||
           danger_type_ == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT ||
           danger_type_ == content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT);
 #else
   return (danger_type_ == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE ||
           danger_type_ == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL);
 #endif
 }
 
-DownloadPersistentStoreInfo DownloadItemImpl::GetPersistentStoreInfo() const {
-  // TODO(asanka): Persist GetTargetFilePath() as well.
-  return DownloadPersistentStoreInfo(GetFullPath(),
-                                     GetURL(),
-                                     GetReferrerUrl(),
-                                     GetStartTime(),
-                                     GetEndTime(),
-                                     GetReceivedBytes(),
-                                     GetTotalBytes(),
-                                     GetState(),
-                                     GetDbHandle(),
-                                     GetOpened());
-}
-
 WebContents* DownloadItemImpl::GetWebContents() const {
   // TODO(rdsmith): Remove null check after removing GetWebContents() from
   // paths that might be used by DownloadItems created from history import.
   // Currently such items have null request_handle_s, where other items
   // (regular and SavePackage downloads) have actual objects off the pointer.
   if (request_handle_.get())
     return request_handle_->GetWebContents();
   return NULL;
 }
 
@@ skipping 111 matching lines @@
 
   bound_net_log_.BeginEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE,
       base::Bind(&download_net_logs::ItemActivatedCallback,
                  this, download_type, &file_name));
 
   // If this is not an active download, end the ACTIVE event now.
   if (!active) {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_IN_HISTORY,
-        net::NetLog::Int64Callback("db_handle", db_handle_));
+        net::NetLog::Int64Callback("id", GetId()));
 
     bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE);
   }
 
   VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 bool DownloadItemImpl::NeedsRename() const {
   DCHECK(target_path_.DirName() == current_path_.DirName());
   return target_path_ != current_path_;
@@ skipping 43 matching lines @@
     ++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 = %" PRId64
         " received = %" PRId64
         " reason = %s"
         " paused = %c"
         " safety = %s"
         " last_modified = '%s'"
         " etag = '%s'"
         " url_chain = \n\t\"%s\"\n\t"
         " full_path = \"%" PRFilePath "\""
         " target_path = \"%" PRFilePath "\"",
-        GetDbHandle(),
         GetTotalBytes(),
         GetReceivedBytes(),
         InterruptReasonDebugString(last_reason_).c_str(),
         IsPaused() ? 'T' : 'F',
         DebugSafetyStateString(GetSafetyState()),
         GetLastModifiedTime().c_str(),
         GetETag().c_str(),
         url_list.c_str(),
         GetFullPath().value().c_str(),
         GetTargetFilePath().value().c_str());
   } else {
     description += base::StringPrintf(" url = \"%s\"", url_list.c_str());
   }
 
   description += " }";
 
   return description;
 }
 
 bool DownloadItemImpl::AllDataSaved() const { return all_data_saved_; }
+
 DownloadItem::DownloadState DownloadItemImpl::GetState() const {
   return state_;
 }
+
 const std::vector<GURL>& DownloadItemImpl::GetUrlChain() const {
   return url_chain_;
 }
+
 const GURL& DownloadItemImpl::GetOriginalUrl() const {
   return url_chain_.front();
 }
+
 const GURL& DownloadItemImpl::GetReferrerUrl() const { return referrer_url_; }
+
 std::string DownloadItemImpl::GetSuggestedFilename() const {
   return suggested_filename_;
 }
+
 std::string DownloadItemImpl::GetContentDisposition() const {
   return content_disposition_;
 }
+
 std::string DownloadItemImpl::GetMimeType() const { return mime_type_; }
+
 std::string DownloadItemImpl::GetOriginalMimeType() const {
   return original_mime_type_;
 }
+
 std::string DownloadItemImpl::GetReferrerCharset() const {
   return referrer_charset_;
 }
+
 std::string DownloadItemImpl::GetRemoteAddress() const {
   return remote_address_;
 }
+
 int64 DownloadItemImpl::GetTotalBytes() const { return total_bytes_; }
+
 void DownloadItemImpl::SetTotalBytes(int64 total_bytes) {
   total_bytes_ = total_bytes;
 }
+
 const std::string& DownloadItemImpl::GetHash() const { return hash_; }
+
 int64 DownloadItemImpl::GetReceivedBytes() const { return received_bytes_; }
+
 const std::string& DownloadItemImpl::GetHashState() const {
   return hash_state_;
 }
+
 int32 DownloadItemImpl::GetId() const { return download_id_.local(); }
+
 DownloadId DownloadItemImpl::GetGlobalId() const { return download_id_; }
+
 base::Time DownloadItemImpl::GetStartTime() const { return start_time_; }
+
 base::Time DownloadItemImpl::GetEndTime() const { return end_time_; }
 
-void DownloadItemImpl::SetIsPersisted() {
-  is_persisted_ = true;
-}
+bool DownloadItemImpl::IsPaused() const { return is_paused_; }
 
-bool DownloadItemImpl::IsPersisted() const {
-  return is_persisted_;
-}
-
-void DownloadItemImpl::SetDbHandle(int64 handle) {
-  db_handle_ = handle;
-
-  bound_net_log_.AddEvent(
-      net::NetLog::TYPE_DOWNLOAD_ITEM_IN_HISTORY,
-      net::NetLog::Int64Callback("db_handle", db_handle_));
-}
-
-int64 DownloadItemImpl::GetDbHandle() const { return db_handle_; }
-bool DownloadItemImpl::IsPaused() const { return is_paused_; }
 bool DownloadItemImpl::GetOpenWhenComplete() const {
   return open_when_complete_;
 }
+
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
+
 bool DownloadItemImpl::GetFileExternallyRemoved() const {
   return file_externally_removed_;
 }
+
 DownloadItem::SafetyState DownloadItemImpl::GetSafetyState() const {
   return safety_state_;
 }
 bool DownloadItemImpl::GetAutoOpened() { return auto_opened_; }
+
 FilePath DownloadItemImpl::GetTargetName() const {
   return target_path_.BaseName();
 }
+
 const FilePath& DownloadItemImpl::GetForcedFilePath() const {
   // TODO(asanka): Get rid of GetForcedFilePath(). We should instead just
   // require that clients respect GetTargetFilePath() if it is already set.
   return forced_file_path_;
 }
+
 bool DownloadItemImpl::HasUserGesture() const {
   return has_user_gesture_;
 };
+
 content::PageTransition DownloadItemImpl::GetTransitionType() const {
   return transition_type_;
 };
+
 bool DownloadItemImpl::IsTemporary() const { return is_temporary_; }
+
 void DownloadItemImpl::SetIsTemporary(bool temporary) {
   is_temporary_ = temporary;
 }
+
 void DownloadItemImpl::SetOpened(bool opened) { opened_ = opened; }
+
 bool DownloadItemImpl::GetOpened() const { return opened_; }
+
 const std::string& DownloadItemImpl::GetLastModifiedTime() const {
   return last_modified_time_;
 }
+
 const std::string& DownloadItemImpl::GetETag() const { return etag_; }
+
 content::DownloadInterruptReason DownloadItemImpl::GetLastReason() const {
   return last_reason_;
 }
+
 void DownloadItemImpl::MockDownloadOpenForTesting() { open_enabled_ = false; }