Save memory in the downloads extension API.

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 46 matching lines @@
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/webui/web_ui_util.h"
 
+namespace events = extensions::event_names;
+
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 
 namespace download_extension_errors {
 
 // Error messages
 const char kGenericError[] = "I'm afraid I can't do that";
@@ skipping 439 matching lines @@
 }
 
 class ExtensionDownloadsEventRouterData : public base::SupportsUserData::Data {
  public:
   static ExtensionDownloadsEventRouterData* Get(DownloadItem* download_item) {
     base::SupportsUserData::Data* data = download_item->GetUserData(kKey);
     return (data == NULL) ? NULL :
         static_cast<ExtensionDownloadsEventRouterData*>(data);
   }
 
+  static void Remove(DownloadItem* download_item) {
+    download_item->RemoveUserData(kKey);
+  }
+
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
       scoped_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
         json_(json_item.Pass()),
         determined_conflict_action_(
             extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY) {
     download_item->SetUserData(kKey, this);
   }
@@ skipping 656 matching lines @@
 }
 
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile,
     DownloadManager* manager)
     : profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(notifier_(manager, this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
-    event_router();
+      event_router();
   if (router)
-    router->RegisterObserver(
-        this, extensions::event_names::kOnDownloadDeterminingFilename);
+    router->RegisterObserver(this, events::kOnDownloadDeterminingFilename);
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
-    event_router();
+      event_router();
   if (router)
     router->UnregisterObserver(this);
 }
 
 // The method by which extensions hook into the filename determination process
 // is based on the method by which the omnibox API allows extensions to hook
 // into the omnibox autocompletion process. Extensions that wish to play a part
 // in the filename determination process call
 // chrome.downloads.onDeterminingFilename.addListener, which adds an
 // EventListener object to ExtensionEventRouter::listeners().
@@ skipping 17 matching lines @@
 // then the extension that was last installed wins.
 
 void ExtensionDownloadsEventRouter::OnDeterminingFilename(
     DownloadItem* item,
     const base::FilePath& suggested_path,
     const base::Closure& no_change,
     const FilenameChangedCallback& change) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ExtensionDownloadsEventRouterData* data =
       ExtensionDownloadsEventRouterData::Get(item);
+  if (!data) {
+    no_change.Run();
+    return;
+  }
   data->ClearPendingDeterminers();
   data->set_filename_change_callbacks(no_change, change);
   bool any_determiners = false;
   base::DictionaryValue* json = DownloadItemToJSON(
       item, profile_->IsOffTheRecord()).release();
   json->SetString(kFilenameKey, suggested_path.LossyDisplayName());
-  DispatchEvent(extensions::event_names::kOnDownloadDeterminingFilename,
+  DispatchEvent(events::kOnDownloadDeterminingFilename,
                 false,
                 base::Bind(&OnDeterminingFilenameWillDispatchCallback,
                            &any_determiners,
                            data),
                 json);
   if (!any_determiners) {
     data->ClearPendingDeterminers();
     no_change.Run();
   }
 }
@@ skipping 40 matching lines @@
     // forever waiting for this ext_id to report.
     *error = download_extension_errors::kInvalidFilenameError;
     return false;
   }
   return true;
 }
 
 void ExtensionDownloadsEventRouter::OnListenerRemoved(
     const extensions::EventListenerInfo& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (details.event_name !=
-      extensions::event_names::kOnDownloadDeterminingFilename)
-    return;
   DownloadManager* manager = notifier_.GetManager();
   if (!manager)
     return;
+  bool determiner_removed = (
+      details.event_name == events::kOnDownloadDeterminingFilename);
+  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
+      event_router();
+  bool any_listeners =
+    router->HasEventListener(events::kOnDownloadChanged) ||
+    router->HasEventListener(events::kOnDownloadDeterminingFilename);
+  if (!determiner_removed && any_listeners)
+    return;
   DownloadManager::DownloadVector items;
   manager->GetAllDownloads(&items);
-  // Notify any items that may be waiting for callbacks from this
-  // extension/determiner.
   for (DownloadManager::DownloadVector::const_iterator iter =
        items.begin();
        iter != items.end(); ++iter) {
     ExtensionDownloadsEventRouterData* data =
         ExtensionDownloadsEventRouterData::Get(*iter);
-    // This will almost always be a no-op, however, it is possible for an
-    // extension renderer to be unloaded while a download item is waiting
-    // for a determiner. In that case, the download item should proceed.
-    if (data)
+    if (!data)
+      continue;
+    if (determiner_removed) {
+      // Notify any items that may be waiting for callbacks from this
+      // extension/determiner.  This will almost always be a no-op, however, it
+      // is possible for an extension renderer to be unloaded while a download
+      // item is waiting for a determiner. In that case, the download item
+      // should proceed.
       data->DeterminerRemoved(details.extension_id);
+    }
+    if (!any_listeners) {
+      ExtensionDownloadsEventRouterData::Remove(*iter);
+    }
   }
 }
 
 // That's all the methods that have to do with filename determination. The rest
 // have to do with the other, less special events.
 
 void ExtensionDownloadsEventRouter::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
 
+  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
+      event_router();
+  // Avoid allocating a bunch of memory in DownloadItemToJSON if it isn't going
+  // to be used.
+  if (!router ||
+      (!router->HasEventListener(events::kOnDownloadCreated) &&
+       !router->HasEventListener(events::kOnDownloadChanged) &&
+       !router->HasEventListener(events::kOnDownloadDeterminingFilename))) {
+    return;
+  }
   scoped_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_->IsOffTheRecord()));
-  DispatchEvent(extensions::event_names::kOnDownloadCreated,
+  DispatchEvent(events::kOnDownloadCreated,
                 true,
                 extensions::Event::WillDispatchCallback(),
                 json_item->DeepCopy());
-  if (!ExtensionDownloadsEventRouterData::Get(download_item))
+  if (!ExtensionDownloadsEventRouterData::Get(download_item) &&
+      (router->HasEventListener(events::kOnDownloadChanged) ||
+       router->HasEventListener(events::kOnDownloadDeterminingFilename))) {
     new ExtensionDownloadsEventRouterData(download_item, json_item.Pass());
+  }
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (download_item->IsTemporary())
-    return;
-
+  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
+      event_router();
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
+  if (download_item->IsTemporary() ||
+      !router->HasEventListener(events::kOnDownloadChanged)) {
+    return;
+  }
   if (!data) {
-    // The download_item probably transitioned from temporary to not temporary.
-    OnDownloadCreated(manager, download_item);
-    return;
+    // The download_item probably transitioned from temporary to not temporary,
+    // or else an event listener was added.
+    data = new ExtensionDownloadsEventRouterData(
+        download_item,
+        scoped_ptr<base::DictionaryValue>(new base::DictionaryValue()));
   }
   scoped_ptr<base::DictionaryValue> new_json(DownloadItemToJSON(
       download_item, profile_->IsOffTheRecord()));
   scoped_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
   delta->SetInteger(kIdKey, download_item->GetId());
   std::set<std::string> new_fields;
   bool changed = false;
 
   // For each field in the new json representation of the download_item except
   // the bytesReceived field, if the field has changed from the previous old
@@ skipping 22 matching lines @@
     if (new_fields.find(iter.key()) == new_fields.end()) {
       delta->Set(iter.key() + ".previous", iter.value().DeepCopy());
       changed = true;
     }
   }
 
   // Update the OnChangedStat and dispatch the event if something significant
   // changed. Replace the stored json with the new json.
   data->OnItemUpdated();
   if (changed) {
-    DispatchEvent(extensions::event_names::kOnDownloadChanged,
+    DispatchEvent(events::kOnDownloadChanged,
                   true,
                   extensions::Event::WillDispatchCallback(),
                   delta.release());
     data->OnChangedFired();
   }
   data->set_json(new_json.Pass());
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
-  DispatchEvent(extensions::event_names::kOnDownloadErased,
+  DispatchEvent(events::kOnDownloadErased,
                 true,
                 extensions::Event::WillDispatchCallback(),
                 base::Value::CreateIntegerValue(download_item->GetId()));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const char* event_name,
     bool include_incognito,
     const extensions::Event::WillDispatchCallback& will_dispatch_callback,
     base::Value* arg) {
@@ skipping 19 matching lines @@
   DownloadsNotificationSource notification_source;
   notification_source.event_name = event_name;
   notification_source.profile = profile_;
   content::Source<DownloadsNotificationSource> content_source(
       &notification_source);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
       content_source,
       content::Details<std::string>(&json_args));
 }