Implement chrome.experimental.downloads.search()

content/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 "content/browser/download/download_item.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/basictypes.h"
@@ skipping 45 matching lines @@
 const int kUpdateTimeMs = 1000;
 
 static void DeleteDownloadedFile(const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Make sure we only delete files.
   if (!file_util::DirectoryExists(path))
     file_util::Delete(path, false);
 }
 
-const char* DebugSafetyStateString(DownloadItem::SafetyState state) {
+const char* DebugSafetyStateString(DownloadItemInterface::SafetyState state) {
   switch (state) {
-    case DownloadItem::SAFE:
+    case DownloadItemInterface::SAFE:
       return "SAFE";
-    case DownloadItem::DANGEROUS:
+    case DownloadItemInterface::DANGEROUS:
       return "DANGEROUS";
-    case DownloadItem::DANGEROUS_BUT_VALIDATED:
+    case DownloadItemInterface::DANGEROUS_BUT_VALIDATED:
       return "DANGEROUS_BUT_VALIDATED";
     default:
       NOTREACHED() << "Unknown safety state " << state;
       return "unknown";
   };
 }
 
-const char* DebugDownloadStateString(DownloadItem::DownloadState state) {
+const char* DebugDownloadStateString(
+    DownloadItemInterface::DownloadState state) {
   switch (state) {
-    case DownloadItem::IN_PROGRESS:
+    case DownloadItemInterface::IN_PROGRESS:
       return "IN_PROGRESS";
-    case DownloadItem::COMPLETE:
+    case DownloadItemInterface::COMPLETE:
       return "COMPLETE";
-    case DownloadItem::CANCELLED:
+    case DownloadItemInterface::CANCELLED:
       return "CANCELLED";
-    case DownloadItem::REMOVING:
+    case DownloadItemInterface::REMOVING:
       return "REMOVING";
-    case DownloadItem::INTERRUPTED:
+    case DownloadItemInterface::INTERRUPTED:
       return "INTERRUPTED";
     default:
       NOTREACHED() << "Unknown download state " << state;
       return "unknown";
   };
 }
 
-DownloadItem::SafetyState GetSafetyState(bool dangerous_file,
+DownloadItemInterface::SafetyState GetSafetyState(bool dangerous_file,
                                          bool dangerous_url) {
   return (dangerous_url || dangerous_file) ?
-      DownloadItem::DANGEROUS : DownloadItem::SAFE;
+      DownloadItemInterface::DANGEROUS : DownloadItemInterface::SAFE;
 }
 
 // Note: When a download has both |dangerous_file| and |dangerous_url| set,
 // danger type is set to DANGEROUS_URL since the risk of dangerous URL
 // overweights that of dangerous file type.
-DownloadItem::DangerType GetDangerType(bool dangerous_file,
+DownloadItemInterface::DangerType GetDangerType(bool dangerous_file,
                                        bool dangerous_url) {
   if (dangerous_url) {
     // dangerous URL overweights dangerous file. We check dangerous URL first.
-    return DownloadItem::DANGEROUS_URL;
+    return DownloadItemInterface::DANGEROUS_URL;
   }
-  return dangerous_file ?
-      DownloadItem::DANGEROUS_FILE : DownloadItem::NOT_DANGEROUS;
+  return dangerous_file ? DownloadItemInterface::DANGEROUS_FILE
+                        : DownloadItemInterface::NOT_DANGEROUS;
 }
 
 }  // namespace
 
 // 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;
 
 // Constructor for reading from the history service.
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const DownloadPersistentStoreInfo& info)
     : download_id_(download_manager->GetNextId()),
       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)),
+      state_(static_cast<DownloadItemInterface::DownloadState>(info.state)),
       start_time_(info.start_time),
       end_time_(info.end_time),
       db_handle_(info.db_handle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
-      safety_state_(SAFE),
+      safety_state_(DownloadItemInterface::SAFE),
       auto_opened_(false),
       is_otr_(false),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(info.opened),
       open_enabled_(true),
       delegate_delayed_complete_(false) {
   if (IsInProgress())
-    state_ = CANCELLED;
+    state_ = DownloadItemInterface::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,
                            DownloadRequestHandleInterface* request_handle,
                            bool is_otr)
     : state_info_(info.original_name, info.save_info.file_path,
                   info.has_user_gesture, info.transition_type,
                   info.prompt_user_for_save_location, info.path_uniquifier,
                   false, false),
       request_handle_(request_handle),
       download_id_(info.download_id),
       full_path_(info.path),
       url_chain_(info.url_chain),
       referrer_url_(info.referrer_url),
       suggested_filename_(UTF16ToUTF8(info.save_info.suggested_name)),
       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_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks::Now()),
-      state_(IN_PROGRESS),
+      state_(DownloadItemInterface::IN_PROGRESS),
       start_time_(info.start_time),
       db_handle_(DownloadItem::kUninitializedHandle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
-      safety_state_(SAFE),
+      safety_state_(DownloadItemInterface::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),
       delegate_delayed_complete_(false) {
   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,
                            DownloadId download_id)
     : download_id_(download_id),
       full_path_(path),
       url_chain_(1, url),
       referrer_url_(GURL()),
       total_bytes_(0),
       received_bytes_(0),
       last_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks::Now()),
-      state_(IN_PROGRESS),
+      state_(DownloadItemInterface::IN_PROGRESS),
       start_time_(base::Time::Now()),
       db_handle_(DownloadItem::kUninitializedHandle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
-      safety_state_(SAFE),
+      safety_state_(DownloadItemInterface::SAFE),
       auto_opened_(false),
       is_otr_(is_otr),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true),
       delegate_delayed_complete_(false) {
   Init(true /* actively downloading */);
 }
 
 DownloadItem::~DownloadItem() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  TransitionTo(REMOVING);
+  TransitionTo(DownloadItemInterface::REMOVING);
   download_manager_->AssertQueueStateConsistent(this);
 }
 
 void DownloadItem::AddObserver(Observer* observer) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   observers_.AddObserver(observer);
 }
 
@@ skipping 56 matching lines @@
 
 void DownloadItem::ShowDownloadInShell() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   content::GetContentClient()->browser()->ShowItemInFolder(full_path());
 }
 
 void DownloadItem::DangerousDownloadValidated() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(DANGEROUS, safety_state());
+  DCHECK_EQ(DownloadItemInterface::DANGEROUS, safety_state());
 
   UMA_HISTOGRAM_ENUMERATION("Download.DangerousDownloadValidated",
                             GetDangerType(),
-                            DANGEROUS_TYPE_MAX);
+                            DownloadItemInterface::DANGEROUS_TYPE_MAX);
 
-  safety_state_ = DANGEROUS_BUT_VALIDATED;
+  safety_state_ = DownloadItemInterface::DANGEROUS_BUT_VALIDATED;
   UpdateObservers();
 
   download_manager_->MaybeCompleteDownload(this);
 }
 
 void DownloadItem::UpdateSize(int64 bytes_so_far) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   received_bytes_ = bytes_so_far;
@@ skipping 46 matching lines @@
 
   VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   if (!IsPartialDownload()) {
     // Small downloads might be complete before this method has
     // a chance to run.
     return;
   }
 
   download_stats::RecordDownloadCount(download_stats::CANCELLED_COUNT);
 
-  TransitionTo(CANCELLED);
+  TransitionTo(DownloadItemInterface::CANCELLED);
   StopProgressTimer();
   if (user_cancel)
     download_manager_->DownloadCancelledInternal(this);
 }
 
 void DownloadItem::MarkAsComplete() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
-  TransitionTo(COMPLETE);
+  TransitionTo(DownloadItemInterface::COMPLETE);
 }
 
 void DownloadItem::DelayedDownloadOpened() {
   auto_opened_ = true;
   Completed();
 }
 
 void DownloadItem::OnAllDataSaved(int64 size) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 10 matching lines @@
 }
 
 void DownloadItem::Completed() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(20) << __FUNCTION__ << "() " << DebugString(false);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
-  TransitionTo(COMPLETE);
+  TransitionTo(DownloadItemInterface::COMPLETE);
   download_manager_->DownloadCompleted(id());
   download_stats::RecordDownloadCompleted(start_tick_, received_bytes_);
 
   if (auto_opened_) {
     // If it was already handled by the delegate, do nothing.
   } else if (open_when_complete() ||
              ShouldOpenFileBasedOnExtension() ||
              is_temporary()) {
     // If the download is temporary, like in drag-and-drop, do not open it but
     // we still need to set it auto-opened so that it can be removed from the
     // download shelf.
     if (!is_temporary())
       OpenDownload();
 
     auto_opened_ = true;
     UpdateObservers();
   }
 }
 
-void DownloadItem::TransitionTo(DownloadState new_state) {
+void DownloadItem::TransitionTo(
+    DownloadItemInterface::DownloadState new_state) {
   if (state_ == new_state)
     return;
 
   state_ = new_state;
   UpdateObservers();
 }
 
 void DownloadItem::UpdateSafetyState() {
-  SafetyState updated_value(
+  DownloadItemInterface::SafetyState updated_value(
       GetSafetyState(state_info_.is_dangerous_file,
                      state_info_.is_dangerous_url));
   if (updated_value != safety_state_) {
     safety_state_ = updated_value;
     UpdateObservers();
   }
 }
 
 void DownloadItem::UpdateTarget() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (state_info_.target_name.value().empty())
     state_info_.target_name = full_path_.BaseName();
 }
 
 void DownloadItem::Interrupted(int64 size, InterruptReason reason) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsInProgress())
     return;
 
   last_reason_ = reason;
   UpdateSize(size);
   StopProgressTimer();
   download_stats::RecordDownloadInterrupted(reason,
                                             received_bytes_,
                                             total_bytes_);
-  TransitionTo(INTERRUPTED);
+  TransitionTo(DownloadItemInterface::INTERRUPTED);
 }
 
 void DownloadItem::Delete(DeleteReason reason) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   switch (reason) {
     case DELETE_DUE_TO_USER_DISCARD:
       UMA_HISTOGRAM_ENUMERATION("Download.UserDiscard", GetDangerType(),
-                                DANGEROUS_TYPE_MAX);
+                                DownloadItemInterface::DANGEROUS_TYPE_MAX);
       break;
     case DELETE_DUE_TO_BROWSER_SHUTDOWN:
       UMA_HISTOGRAM_ENUMERATION("Download.Discard", GetDangerType(),
-                                DANGEROUS_TYPE_MAX);
+                                DownloadItemInterface::DANGEROUS_TYPE_MAX);
       break;
     default:
       NOTREACHED();
   }
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DeleteDownloadedFile, full_path_));
   Remove();
   // We have now been deleted.
 }
 
 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);
 
-  TransitionTo(REMOVING);
+  TransitionTo(DownloadItemInterface::REMOVING);
   download_manager_->RemoveDownload(db_handle_);
   // 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)
@@ skipping 50 matching lines @@
   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__ << "()"
            << " needs rename = " << NeedsRename()
            << " " << DebugString(true);
-  DCHECK_NE(DANGEROUS, safety_state());
+  DCHECK_NE(DownloadItemInterface::DANGEROUS, safety_state());
   DCHECK(file_manager);
 
   if (NeedsRename()) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         base::Bind(&DownloadFileManager::RenameCompletingDownloadFile,
                    file_manager, global_id(),
-                   GetTargetFilePath(), safety_state() == SAFE));
+                   GetTargetFilePath(), safety_state() == DownloadItemInterface::SAFE));
     return;
   }
 
   Completed();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DownloadFileManager::CompleteDownload,
                                      file_manager, global_id()));
 }
 
@@ skipping 47 matching lines @@
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true);
   state_info_ = state;
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true);
 
   UpdateSafetyState();
 }
 
-DownloadItem::DangerType DownloadItem::GetDangerType() const {
+DownloadItemInterface::DangerType DownloadItem::GetDangerType() const {
   return ::GetDangerType(state_info_.is_dangerous_file,
                          state_info_.is_dangerous_url);
 }
 
 bool DownloadItem::IsDangerous() const {
-  return GetDangerType() != DownloadItem::NOT_DANGEROUS;
+  return GetDangerType() != DownloadItemInterface::NOT_DANGEROUS;
 }
 
 void DownloadItem::MarkFileDangerous() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   state_info_.is_dangerous_file = true;
   UpdateSafetyState();
 }
 
@@ skipping 31 matching lines @@
 FilePath DownloadItem::GetFileNameToReportUser() const {
   if (state_info_.path_uniquifier > 0) {
     FilePath name(state_info_.target_name);
     DownloadFile::AppendNumberToPath(&name, state_info_.path_uniquifier);
     return name;
   }
   return state_info_.target_name;
 }
 
 FilePath DownloadItem::GetUserVerifiedFilePath() const {
-  return (safety_state_ == DownloadItem::SAFE) ?
+  return (safety_state_ == DownloadItemInterface::SAFE) ?
       GetTargetFilePath() : full_path_;
 }
 
 void DownloadItem::OffThreadCancel(DownloadFileManager* file_manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   request_handle_->CancelRequest();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DownloadFileManager::CancelDownload,
                                      file_manager, global_id()));
 }
 
 void DownloadItem::Init(bool active) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UpdateTarget();
   if (active) {
     StartProgressTimer();
     download_stats::RecordDownloadCount(download_stats::START_COUNT);
   }
   VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 // TODO(ahendrickson) -- Move |INTERRUPTED| from |IsCancelled()| to
 // |IsPartialDownload()|, when resuming interrupted downloads is implemented.
 bool DownloadItem::IsPartialDownload() const {
-  return (state_ == IN_PROGRESS);
+  return (state_ == DownloadItemInterface::IN_PROGRESS);
 }
 
 bool DownloadItem::IsInProgress() const {
-  return (state_ == IN_PROGRESS);
+  return (state_ == DownloadItemInterface::IN_PROGRESS);
 }
 
 bool DownloadItem::IsCancelled() const {
-  return (state_ == CANCELLED) ||
-         (state_ == INTERRUPTED);
+  return (state_ == DownloadItemInterface::CANCELLED) ||
+         (state_ == DownloadItemInterface::INTERRUPTED);
 }
 
 bool DownloadItem::IsInterrupted() const {
-  return (state_ == INTERRUPTED);
+  return (state_ == DownloadItemInterface::INTERRUPTED);
 }
 
 bool DownloadItem::IsComplete() const {
-  return (state_ == COMPLETE);
+  return (state_ == DownloadItemInterface::COMPLETE);
 }
 
 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"
@@ skipping 36 matching lines @@
         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;
 }