Reland DownloadItem::Observer::OnDownloadDestroyed() replaces DownloadItem::REMOVING

chrome/browser/extensions/api/downloads/downloads_api.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/extensions/api/downloads/downloads_api.h"
 
 #include <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
@@ skipping 121 matching lines @@
 };
 COMPILE_ASSERT(arraysize(kDangerStrings) == content::DOWNLOAD_DANGER_TYPE_MAX,
                download_danger_type_enum_changed);
 
 // Note: Any change to the state strings, should be accompanied by a
 // corresponding change to downloads.json.
 const char* kStateStrings[] = {
   kStateInProgress,
   kStateComplete,
   kStateInterrupted,
-  NULL,
   kStateInterrupted,
 };
 COMPILE_ASSERT(arraysize(kStateStrings) == DownloadItem::MAX_DOWNLOAD_STATE,
                download_item_state_enum_changed);
 
 const char* DangerString(content::DownloadDangerType danger) {
   DCHECK(danger >= 0);
   DCHECK(danger < static_cast<content::DownloadDangerType>(
       arraysize(kDangerStrings)));
+  if (danger < 0 || danger >= static_cast<content::DownloadDangerType>(
+      arraysize(kDangerStrings)))
+    return "";
   return kDangerStrings[danger];
 }
 
 content::DownloadDangerType DangerEnumFromString(const std::string& danger) {
   for (size_t i = 0; i < arraysize(kDangerStrings); ++i) {
     if (danger == kDangerStrings[i])
       return static_cast<content::DownloadDangerType>(i);
   }
   return content::DOWNLOAD_DANGER_TYPE_MAX;
 }
 
 const char* StateString(DownloadItem::DownloadState state) {
   DCHECK(state >= 0);
   DCHECK(state < static_cast<DownloadItem::DownloadState>(
       arraysize(kStateStrings)));
-  DCHECK(state != DownloadItem::REMOVING);
+  if (state < 0 || state >= static_cast<DownloadItem::DownloadState>(
+      arraysize(kStateStrings)))
+    return "";
   return kStateStrings[state];
 }
 
 DownloadItem::DownloadState StateEnumFromString(const std::string& state) {
   for (size_t i = 0; i < arraysize(kStateStrings); ++i) {
     if ((kStateStrings[i] != NULL) && (state == kStateStrings[i]))
       return static_cast<DownloadItem::DownloadState>(i);
   }
   return DownloadItem::MAX_DOWNLOAD_STATE;
 }
@@ skipping 635 matching lines @@
 ExtensionDownloadsEventRouter::OnChangedStat::OnChangedStat()
   : fires(0),
     total(0) {
 }
 
 ExtensionDownloadsEventRouter::OnChangedStat::~OnChangedStat() {
   if (total > 0)
     UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged", (fires * 100 / total));
 }
 
+void ExtensionDownloadsEventRouter::OnDownloadDestroyed(DownloadItem* item) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  int download_id = item->GetId();
+  downloads_.erase(download_id);
+  item->RemoveObserver(this);
+  delete item_jsons_[download_id];
+  item_jsons_.erase(download_id);
+  delete on_changed_stats_[download_id];
+  on_changed_stats_.erase(download_id);
+}
+
+void ExtensionDownloadsEventRouter::OnDownloadRemoved(DownloadItem* item) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!profile_)
+    return;
+  int download_id = item->GetId();
+  DispatchEvent(extensions::event_names::kOnDownloadErased,
+                base::Value::CreateIntegerValue(download_id));
+}
+
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(DownloadItem* item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!profile_)
+    return;
   int download_id = item->GetId();
-  if (item->GetState() == DownloadItem::REMOVING) {
-    // The REMOVING state indicates that this item is being erased.
-    // Let's unregister as an observer so that we don't see any more updates
-    // from it, dispatch the onErased event, and remove its json and is
-    // OnChangedStat from our maps.
-    downloads_.erase(download_id);
-    item->RemoveObserver(this);
-    DispatchEvent(extensions::event_names::kOnDownloadErased,
-                  base::Value::CreateIntegerValue(download_id));
-    delete item_jsons_[download_id];
-    item_jsons_.erase(download_id);
-    delete on_changed_stats_[download_id];
-    on_changed_stats_.erase(download_id);
-    return;
-  }
 
   base::DictionaryValue* old_json = item_jsons_[download_id];
   scoped_ptr<base::DictionaryValue> new_json(DownloadItemToJSON(item));
   scoped_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
   delta->SetInteger(kIdKey, download_id);
   std::set<std::string> new_fields;
   bool changed = false;
 
   // For each field in the new json representation of the item except the
   // bytesReceived field, if the field has changed from the previous old json,
@@ skipping 28 matching lines @@
   // Update the OnChangedStat and dispatch the event if something significant
   // changed. Replace the stored json with the new json.
   ++(on_changed_stats_[download_id]->total);
   if (changed) {
     DispatchEvent(extensions::event_names::kOnDownloadChanged, delta.release());
     ++(on_changed_stats_[download_id]->fires);
   }
   item_jsons_[download_id]->Swap(new_json.get());
 }
 
-void ExtensionDownloadsEventRouter::OnDownloadOpened(DownloadItem* item) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-}
-
 void ExtensionDownloadsEventRouter::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(manager_ == manager);
   if (download_item->IsTemporary()) return;
 
   download_item->AddObserver(this);
   scoped_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item));
   DispatchEvent(extensions::event_names::kOnDownloadCreated,
                 json_item->DeepCopy());
   int32 download_id = download_item->GetId();
   DCHECK(item_jsons_.find(download_id) == item_jsons_.end());
   on_changed_stats_[download_id] = new OnChangedStat();
   item_jsons_[download_id] = json_item.release();
   downloads_[download_id] = download_item;
 }
 
 void ExtensionDownloadsEventRouter::ManagerGoingDown(
     DownloadManager* manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   manager_->RemoveObserver(this);
   manager_ = NULL;
+  profile_ = NULL;
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const char* event_name, base::Value* arg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(args.get(), &json_args);
 
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name,
       args.Pass(),
       profile_,
       GURL(),
       extensions::EventFilteringInfo());
 
   DownloadsNotificationSource notification_source;
   notification_source.event_name = event_name;
   notification_source.profile = profile_;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
       content::Source<DownloadsNotificationSource>(&notification_source),
       content::Details<std::string>(&json_args));
 }