downloads: add the ability to undo download removal.

chrome/browser/ui/webui/downloads_dom_handler.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 "chrome/browser/ui/webui/downloads_dom_handler.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/supports_user_data.h"
 #include "base/threading/thread.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_danger_prompt.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_query.h"
@@ skipping 37 matching lines @@
   DOWNLOADS_DOM_EVENT_SHOW = 5,
   DOWNLOADS_DOM_EVENT_PAUSE = 6,
   DOWNLOADS_DOM_EVENT_REMOVE = 7,
   DOWNLOADS_DOM_EVENT_CANCEL = 8,
   DOWNLOADS_DOM_EVENT_CLEAR_ALL = 9,
   DOWNLOADS_DOM_EVENT_OPEN_FOLDER = 10,
   DOWNLOADS_DOM_EVENT_RESUME = 11,
   DOWNLOADS_DOM_EVENT_MAX
 };
 
+static const char kKey[] = "DownloadsDOMHandlerData";
+
+class DownloadsDOMHandlerData : public base::SupportsUserData::Data {
+ public:
+  static DownloadsDOMHandlerData* Get(content::DownloadItem* item) {
+    return static_cast<DownloadsDOMHandlerData*>(item->GetUserData(kKey));
+  }
+
+  static const DownloadsDOMHandlerData* Get(const content::DownloadItem* item) {
+    return static_cast<DownloadsDOMHandlerData*>(item->GetUserData(kKey));
+  }
+
+  static void Set(content::DownloadItem* item, DownloadsDOMHandlerData* data) {
+    item->SetUserData(kKey, data);
+  }
+
+  static DownloadsDOMHandlerData* Create(content::DownloadItem* item) {
+    DownloadsDOMHandlerData* data = new DownloadsDOMHandlerData;
+    item->SetUserData(kKey, data);
+    return data;
+  }
+
+  void set_is_removed(bool is_removed) { is_removed_ = is_removed; }
+  bool is_removed() const { return is_removed_; }
+
+ private:
+  bool is_removed_;
+};
+
 void CountDownloadsDOMEvents(DownloadsDOMEvent event) {
   UMA_HISTOGRAM_ENUMERATION("Download.DOMEvent",
                             event,
                             DOWNLOADS_DOM_EVENT_MAX);
 }
 
 // Returns a string constant to be used as the |danger_type| value in
 // CreateDownloadItemValue().  Only return strings for DANGEROUS_FILE,
 // DANGEROUS_URL, DANGEROUS_CONTENT, and UNCOMMON_CONTENT because the
 // |danger_type| value is only defined if the value of |state| is |DANGEROUS|.
@@ skipping 36 matching lines @@
   // any keys in file_value.
   base::DictionaryValue* file_value = new base::DictionaryValue();
 
   file_value->SetInteger(
       "started", static_cast<int>(download_item->GetStartTime().ToTimeT()));
   file_value->SetString(
       "since_string", ui::TimeFormat::RelativeDate(
           download_item->GetStartTime(), NULL));
   file_value->SetString(
       "date_string", base::TimeFormatShortDate(download_item->GetStartTime()));
-  file_value->SetInteger("id", download_item->GetId());
+  file_value->SetString("id", base::Uint64ToString(download_item->GetId()));
 
   base::FilePath download_path(download_item->GetTargetFilePath());
   file_value->Set("file_path", base::CreateFilePathValue(download_path));
   file_value->SetString("file_url",
                         net::FilePathToFileURL(download_path).spec());
 
   extensions::DownloadedByExtension* by_ext =
       extensions::DownloadedByExtension::Get(download_item);
   if (by_ext) {
     file_value->SetString("by_ext_id", by_ext->id());
@@ skipping 78 matching lines @@
       file_value->SetString("state", "CANCELLED");
       file_value->SetBoolean("retry", true);
       break;
 
     case content::DownloadItem::COMPLETE:
       DCHECK(!download_item->IsDangerous());
       file_value->SetString("state", "COMPLETE");
       break;
 
     case content::DownloadItem::MAX_DOWNLOAD_STATE:
-      NOTREACHED() << "state undefined";
+      NOTREACHED();
   }
 
   return file_value;
 }
 
 // Filters out extension downloads and downloads that don't have a filename yet.
 bool IsDownloadDisplayable(const content::DownloadItem& item) {
-  return (!download_crx_util::IsExtensionDownload(item) &&
-          !item.IsTemporary() &&
-          !item.GetFileNameToReportUser().empty() &&
-          !item.GetTargetFilePath().empty());
+  const DownloadsDOMHandlerData* data = DownloadsDOMHandlerData::Get(&item);
+  return !download_crx_util::IsExtensionDownload(item) &&
+         !item.IsTemporary() &&
+         !item.GetFileNameToReportUser().empty() &&
+         !item.GetTargetFilePath().empty() &&
+         (!data || !data->is_removed());
 }
 
 }  // namespace
 
 DownloadsDOMHandler::DownloadsDOMHandler(content::DownloadManager* dlm)
     : main_notifier_(dlm, this),
       update_scheduled_(false),
       weak_ptr_factory_(this) {
   // Create our fileicon data source.
   Profile* profile = Profile::FromBrowserContext(dlm->GetBrowserContext());
   content::URLDataSource::Add(profile, new FileIconSource());
 
   if (profile->IsOffTheRecord()) {
     original_notifier_.reset(new AllDownloadItemNotifier(
         BrowserContext::GetDownloadManager(profile->GetOriginalProfile()),
         this));
   }
 }
 
 DownloadsDOMHandler::~DownloadsDOMHandler() {
+  while (!removed_ids_.empty()) {
+    content::DownloadItem* download = GetDownloadById(removed_ids_.back());
+    removed_ids_.pop_back();
+    if (download)
+      download->Remove();
+  }
 }
 
 // DownloadsDOMHandler, public: -----------------------------------------------
 
 void DownloadsDOMHandler::OnPageLoaded(const base::ListValue* args) {
   SendCurrentDownloads();
 }
 
 void DownloadsDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("onPageLoaded",
@@ skipping 19 matching lines @@
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("pause",
       base::Bind(&DownloadsDOMHandler::HandlePause,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("resume",
       base::Bind(&DownloadsDOMHandler::HandleResume,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("remove",
       base::Bind(&DownloadsDOMHandler::HandleRemove,
                  weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback("undo",
+      base::Bind(&DownloadsDOMHandler::HandleUndo,
+                 weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("cancel",
       base::Bind(&DownloadsDOMHandler::HandleCancel,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("clearAll",
       base::Bind(&DownloadsDOMHandler::HandleClearAll,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback("openDownloadsFolder",
       base::Bind(&DownloadsDOMHandler::HandleOpenDownloadsFolder,
                  weak_ptr_factory_.GetWeakPtr()));
 }
@@ skipping 19 matching lines @@
       query.Search(all_items.begin(), all_items.end(), &filtered_items);
       if (filtered_items.empty())
         return;
     }
     base::ListValue results_value;
     results_value.Append(CreateDownloadItemValue(
         download_item,
         (original_notifier_.get() &&
           (manager == main_notifier_.GetManager()))));
     CallDownloadUpdated(results_value);
+  } else {
+    ScheduleSendCurrentDownloads();
   }
 }
 
 void DownloadsDOMHandler::OnDownloadRemoved(
     content::DownloadManager* manager,
     content::DownloadItem* download_item) {
+  DownloadsDOMHandlerData* data = DownloadsDOMHandlerData::Get(download_item);
+  if (data && data->is_removed())
+    return;
+
   // This relies on |download_item| being removed from DownloadManager in this
   // MessageLoop iteration. |download_item| may not have been removed from
   // DownloadManager when OnDownloadRemoved() is fired, so bounce off the
   // MessageLoop to give it a chance to be removed. SendCurrentDownloads() looks
   // at all downloads, and we do not tell it that |download_item| is being
   // removed. If DownloadManager is ever changed to not immediately remove
   // |download_item| from its map when OnDownloadRemoved is sent, then
   // DownloadsDOMHandler::OnDownloadRemoved() will need to explicitly tell
   // SendCurrentDownloads() that |download_item| was removed. A
   // SupportsUserData::Data would be the correct way to do this.
@@ skipping 72 matching lines @@
   if (file)
     file->Resume();
 }
 
 void DownloadsDOMHandler::HandleRemove(const base::ListValue* args) {
   if (!IsDeletingHistoryAllowed())
     return;
 
   CountDownloadsDOMEvents(DOWNLOADS_DOM_EVENT_REMOVE);
   content::DownloadItem* file = GetDownloadByValue(args);
-  if (file)
-    file->Remove();
+  if (!file)
+    return;
+
+  removed_ids_.push_back(file->GetId());
+  DownloadsDOMHandlerData::Create(file)->set_is_removed(true);
+  file->UpdateObservers();
+}
+
+void DownloadsDOMHandler::HandleUndo(const base::ListValue* args) {
+  // TODO(dbeam): handle more than removed downloads someday?
+  if (removed_ids_.empty())
+    return;
+
+  uint32 last_removed_id = removed_ids_.back();
+  removed_ids_.pop_back();
+
+  content::DownloadItem* download = GetDownloadById(last_removed_id);
+  if (!download)
+    return;
+
+  DownloadsDOMHandlerData::Set(download, nullptr);
+  download->UpdateObservers();
 }
 
 void DownloadsDOMHandler::HandleCancel(const base::ListValue* args) {
   CountDownloadsDOMEvents(DOWNLOADS_DOM_EVENT_CANCEL);
   content::DownloadItem* file = GetDownloadByValue(args);
   if (file)
     file->Cancel(true);
 }
 
 void DownloadsDOMHandler::HandleClearAll(const base::ListValue* args) {
@@ skipping 55 matching lines @@
   }
   DownloadQuery query;
   if (search_terms_ && !search_terms_->empty()) {
     query.AddFilter(DownloadQuery::FILTER_QUERY, *search_terms_.get());
   }
   query.AddFilter(base::Bind(&IsDownloadDisplayable));
   query.AddSorter(DownloadQuery::SORT_START_TIME, DownloadQuery::DESCENDING);
   query.Limit(kMaxDownloads);
   query.Search(all_items.begin(), all_items.end(), &filtered_items);
   base::ListValue results_value;
-  for (content::DownloadManager::DownloadVector::const_iterator
+  for (content::DownloadManager::DownloadVector::iterator
        iter = filtered_items.begin(); iter != filtered_items.end(); ++iter) {
     results_value.Append(CreateDownloadItemValue(
         *iter,
         (original_notifier_.get() &&
           main_notifier_.GetManager() &&
           (main_notifier_.GetManager()->GetDownload((*iter)->GetId()) ==
           *iter))));
   }
   CallDownloadsList(results_value);
 }
@@ skipping 27 matching lines @@
 
 bool DownloadsDOMHandler::IsDeletingHistoryAllowed() {
   content::DownloadManager* manager = main_notifier_.GetManager();
   return (manager &&
           Profile::FromBrowserContext(manager->GetBrowserContext())->
               GetPrefs()->GetBoolean(prefs::kAllowDeletingBrowserHistory));
 }
 
 content::DownloadItem* DownloadsDOMHandler::GetDownloadByValue(
     const base::ListValue* args) {
-  int download_id = -1;
-  if (!ExtractIntegerValue(args, &download_id))
-    return NULL;
+  std::string download_id;
+  if (!args->GetString(0, &download_id)) {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  uint64 id;
+  if (!base::StringToUint64(download_id, &id)) {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  return GetDownloadById(static_cast<uint32>(id));
+}
+
+content::DownloadItem* DownloadsDOMHandler::GetDownloadById(uint32 id) {
   content::DownloadItem* item = NULL;
   if (main_notifier_.GetManager())
-    item = main_notifier_.GetManager()->GetDownload(download_id);
+    item = main_notifier_.GetManager()->GetDownload(id);
   if (!item && original_notifier_.get() && original_notifier_->GetManager())
-    item = original_notifier_->GetManager()->GetDownload(download_id);
+    item = original_notifier_->GetManager()->GetDownload(id);
   return item;
 }
 
 content::WebContents* DownloadsDOMHandler::GetWebUIWebContents() {
   return web_ui()->GetWebContents();
 }
 
 void DownloadsDOMHandler::CallDownloadsList(const base::ListValue& downloads) {
   web_ui()->CallJavascriptFunction("downloadsList", downloads);
 }
 
 void DownloadsDOMHandler::CallDownloadUpdated(
     const base::ListValue& download_item) {
   web_ui()->CallJavascriptFunction("downloadUpdated", download_item);
 }