Use EventRouter::Get instead of ExtensionSystem::Get(browser_context)->event_router()

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 <set>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/download_danger_prompt.h"
 #include "chrome/browser/download/download_file_icon_extractor.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_query.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_stats.h"
 #include "chrome/browser/download/drag_download_item.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_warning_service.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/extensions/api/downloads.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_save_info.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_dispatcher.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_system.h"
 #include "net/base/filename_util.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
@@ skipping 31 matching lines @@
 const char kUserGesture[] = "User gesture required";
 
 }  // namespace download_extension_errors
 
 namespace errors = download_extension_errors;
 
 namespace extensions {
 
 namespace {
 
-namespace downloads = extensions::api::downloads;
+namespace downloads = api::downloads;
 
 // Default icon size for getFileIcon() in pixels.
 const int  kDefaultIconSize = 32;
 
 // Parameter keys
 const char kByExtensionIdKey[] = "byExtensionId";
 const char kByExtensionNameKey[] = "byExtensionName";
 const char kBytesReceivedKey[] = "bytesReceived";
 const char kCanResumeKey[] = "canResume";
 const char kDangerAccepted[] = "accepted";
@@ skipping 143 matching lines @@
     base::Time now = base::Time::Now();
     json->SetString(kEstimatedEndTimeKey, TimeToISO8601(now + time_remaining));
   }
   DownloadedByExtension* by_ext = DownloadedByExtension::Get(download_item);
   if (by_ext) {
     json->SetString(kByExtensionIdKey, by_ext->id());
     json->SetString(kByExtensionNameKey, by_ext->name());
     // Lookup the extension's current name() in case the user changed their
     // language. This won't work if the extension was uninstalled, so the name
     // might be the wrong language.
-    bool include_disabled = true;
-    const extensions::Extension* extension = extensions::ExtensionSystem::Get(
-        profile)->extension_service()->GetExtensionById(
-            by_ext->id(), include_disabled);
+    const Extension* extension =
+        ExtensionRegistry::Get(profile)
+            ->GetExtensionById(by_ext->id(), ExtensionRegistry::EVERYTHING);
     if (extension)
       json->SetString(kByExtensionNameKey, extension->name());
   }
   // TODO(benjhayden): Implement fileSize.
   json->SetDouble(kFileSizeKey, download_item->GetTotalBytes());
   return scoped_ptr<base::DictionaryValue>(json);
 }
 
 class DownloadFileIconExtractorImpl : public DownloadFileIconExtractor {
  public:
@@ skipping 433 matching lines @@
       if (determiners_[index].extension_id == extension_id) {
         found_info = true;
         if (determiners_[index].reported)
           return false;
         determiners_[index].reported = true;
         // Do not use filename if another determiner has already overridden the
         // filename and they take precedence. Extensions that were installed
         // later take precedence over previous extensions.
         if (!filename.empty() ||
             (conflict_action != downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY)) {
-          extensions::ExtensionWarningSet warnings;
+          ExtensionWarningSet warnings;
           std::string winner_extension_id;
           ExtensionDownloadsEventRouter::DetermineFilenameInternal(
               filename,
               conflict_action,
               determiners_[index].extension_id,
               determiners_[index].install_time,
               determiner_.extension_id,
               determiner_.install_time,
               &winner_extension_id,
               &determined_filename_,
               &determined_conflict_action_,
               &warnings);
           if (!warnings.empty())
-            extensions::ExtensionWarningService::NotifyWarningsOnUI(
-                profile, warnings);
+            ExtensionWarningService::NotifyWarningsOnUI(profile, warnings);
           if (winner_extension_id == determiners_[index].extension_id)
             determiner_ = determiners_[index];
         }
         break;
       }
     }
     if (!found_info)
       return false;
     CheckAllDeterminersCalled();
     return true;
@@ skipping 153 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ManagerDestructionObserver);
 };
 
 std::map<DownloadManager*, ManagerDestructionObserver*>*
   ManagerDestructionObserver::manager_file_existence_last_checked_ = NULL;
 
 void OnDeterminingFilenameWillDispatchCallback(
     bool* any_determiners,
     ExtensionDownloadsEventRouterData* data,
     content::BrowserContext* context,
-    const extensions::Extension* extension,
+    const Extension* extension,
     base::ListValue* event_args) {
   *any_determiners = true;
   base::Time installed =
-      extensions::ExtensionPrefs::Get(context)->GetInstallTime(extension->id());
+      ExtensionPrefs::Get(context)->GetInstallTime(extension->id());
   data->AddPendingDeterminer(extension->id(), installed);
 }
 
 bool Fault(bool error,
            const char* message_in,
            std::string* message_out) {
   if (!error)
     return false;
   *message_out = message_in;
   return true;
@@ skipping 436 matching lines @@
 
 bool DownloadsOpenFunction::RunSync() {
   scoped_ptr<downloads::Open::Params> params(
       downloads::Open::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(!user_gesture(), errors::kUserGesture, &error_) ||
       Fault(download_item->GetState() != DownloadItem::COMPLETE,
-            errors::kNotComplete, &error_) ||
-      Fault(!GetExtension()->HasAPIPermission(
-                extensions::APIPermission::kDownloadsOpen),
-            errors::kOpenPermission, &error_))
+            errors::kNotComplete,
+            &error_) ||
+      Fault(!GetExtension()->HasAPIPermission(APIPermission::kDownloadsOpen),
+            errors::kOpenPermission,
+            &error_))
     return false;
   download_item->OpenDownload();
   RecordApiFunctions(DOWNLOADS_FUNCTION_OPEN);
   return true;
 }
 
 DownloadsDragFunction::DownloadsDragFunction() {}
 
 DownloadsDragFunction::~DownloadsDragFunction() {}
 
@@ skipping 22 matching lines @@
 }
 
 DownloadsSetShelfEnabledFunction::DownloadsSetShelfEnabledFunction() {}
 
 DownloadsSetShelfEnabledFunction::~DownloadsSetShelfEnabledFunction() {}
 
 bool DownloadsSetShelfEnabledFunction::RunSync() {
   scoped_ptr<downloads::SetShelfEnabled::Params> params(
       downloads::SetShelfEnabled::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  if (!GetExtension()->HasAPIPermission(
-        extensions::APIPermission::kDownloadsShelf)) {
+  if (!GetExtension()->HasAPIPermission(APIPermission::kDownloadsShelf)) {
     error_ = download_extension_errors::kShelfPermission;
     return false;
   }
 
   RecordApiFunctions(DOWNLOADS_FUNCTION_SET_SHELF_ENABLED);
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
   DownloadService* service = NULL;
   DownloadService* incognito_service = NULL;
@@ skipping 94 matching lines @@
 }
 
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile,
     DownloadManager* manager)
     : profile_(profile),
       notifier_(manager, this),
       extension_registry_observer_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile_);
-  extension_registry_observer_.Add(
-      extensions::ExtensionRegistry::Get(profile_));
-  extensions::EventRouter* router = extensions::EventRouter::Get(profile_);
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
+  EventRouter* router = EventRouter::Get(profile_);
   if (router)
     router->RegisterObserver(this,
                              downloads::OnDeterminingFilename::kEventName);
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  extensions::EventRouter* router = extensions::EventRouter::Get(profile_);
+  EventRouter* router = EventRouter::Get(profile_);
   if (router)
     router->UnregisterObserver(this);
 }
 
 void ExtensionDownloadsEventRouter::
     SetDetermineFilenameTimeoutSecondsForTesting(int s) {
   ExtensionDownloadsEventRouterData::
       SetDetermineFilenameTimeoutSecondsForTesting(s);
 }
 
-void ExtensionDownloadsEventRouter::SetShelfEnabled(
-    const extensions::Extension* extension, bool enabled) {
-  std::set<const extensions::Extension*>::iterator iter =
-    shelf_disabling_extensions_.find(extension);
+void ExtensionDownloadsEventRouter::SetShelfEnabled(const Extension* extension,
+                                                    bool enabled) {
+  std::set<const Extension*>::iterator iter =
+      shelf_disabling_extensions_.find(extension);
   if (iter == shelf_disabling_extensions_.end()) {
     if (!enabled)
       shelf_disabling_extensions_.insert(extension);
   } else if (enabled) {
     shelf_disabling_extensions_.erase(extension);
   }
 }
 
 bool ExtensionDownloadsEventRouter::IsShelfEnabled() const {
   return shelf_disabling_extensions_.empty();
@@ skipping 63 matching lines @@
 
 void ExtensionDownloadsEventRouter::DetermineFilenameInternal(
     const base::FilePath& filename,
     downloads::FilenameConflictAction conflict_action,
     const std::string& suggesting_extension_id,
     const base::Time& suggesting_install_time,
     const std::string& incumbent_extension_id,
     const base::Time& incumbent_install_time,
     std::string* winner_extension_id,
     base::FilePath* determined_filename,
-    downloads::FilenameConflictAction*
-      determined_conflict_action,
-    extensions::ExtensionWarningSet* warnings) {
+    downloads::FilenameConflictAction* determined_conflict_action,
+    ExtensionWarningSet* warnings) {
   DCHECK(!filename.empty() ||
          (conflict_action != downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY));
   DCHECK(!suggesting_extension_id.empty());
 
   if (incumbent_extension_id.empty()) {
     *winner_extension_id = suggesting_extension_id;
     *determined_filename = filename;
     *determined_conflict_action = conflict_action;
     return;
   }
 
   if (suggesting_install_time < incumbent_install_time) {
     *winner_extension_id = incumbent_extension_id;
-    warnings->insert(
-        extensions::ExtensionWarning::CreateDownloadFilenameConflictWarning(
-            suggesting_extension_id,
-            incumbent_extension_id,
-            filename,
-            *determined_filename));
+    warnings->insert(ExtensionWarning::CreateDownloadFilenameConflictWarning(
+        suggesting_extension_id,
+        incumbent_extension_id,
+        filename,
+        *determined_filename));
     return;
   }
 
   *winner_extension_id = suggesting_extension_id;
-  warnings->insert(
-      extensions::ExtensionWarning::CreateDownloadFilenameConflictWarning(
-          incumbent_extension_id,
-          suggesting_extension_id,
-          *determined_filename,
-          filename));
+  warnings->insert(ExtensionWarning::CreateDownloadFilenameConflictWarning(
+      incumbent_extension_id,
+      suggesting_extension_id,
+      *determined_filename,
+      filename));
   *determined_filename = filename;
   *determined_conflict_action = conflict_action;
 }
 
 bool ExtensionDownloadsEventRouter::DetermineFilename(
     Profile* profile,
     bool include_incognito,
     const std::string& ext_id,
     int download_id,
     const base::FilePath& const_filename,
@@ skipping 28 matching lines @@
   if (Fault(!data->DeterminerCallback(
                 profile, ext_id, filename, conflict_action),
             errors::kUnexpectedDeterminer, error) ||
       Fault((!const_filename.empty() && !valid_filename),
             errors::kInvalidFilename, error))
     return false;
   return true;
 }
 
 void ExtensionDownloadsEventRouter::OnListenerRemoved(
-    const extensions::EventListenerInfo& details) {
+    const EventListenerInfo& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadManager* manager = notifier_.GetManager();
   if (!manager)
     return;
   bool determiner_removed = (
       details.event_name == downloads::OnDeterminingFilename::kEventName);
-  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
-      event_router();
+  EventRouter* router = EventRouter::Get(profile_);
   bool any_listeners =
     router->HasEventListener(downloads::OnChanged::kEventName) ||
     router->HasEventListener(downloads::OnDeterminingFilename::kEventName);
   if (!determiner_removed && any_listeners)
     return;
   DownloadManager::DownloadVector items;
   manager->GetAllDownloads(&items);
   for (DownloadManager::DownloadVector::const_iterator iter =
        items.begin();
        iter != items.end(); ++iter) {
@@ skipping 18 matching lines @@
 
 // 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_CURRENTLY_ON(BrowserThread::UI);
   if (download_item->IsTemporary())
     return;
 
-  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
-      event_router();
+  EventRouter* router = EventRouter::Get(profile_);
   // Avoid allocating a bunch of memory in DownloadItemToJSON if it isn't going
   // to be used.
   if (!router ||
       (!router->HasEventListener(downloads::OnCreated::kEventName) &&
        !router->HasEventListener(downloads::OnChanged::kEventName) &&
        !router->HasEventListener(
             downloads::OnDeterminingFilename::kEventName))) {
     return;
   }
   scoped_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_));
   DispatchEvent(downloads::OnCreated::kEventName,
                 true,
-                extensions::Event::WillDispatchCallback(),
+                Event::WillDispatchCallback(),
                 json_item->DeepCopy());
   if (!ExtensionDownloadsEventRouterData::Get(download_item) &&
       (router->HasEventListener(downloads::OnChanged::kEventName) ||
        router->HasEventListener(
            downloads::OnDeterminingFilename::kEventName))) {
     new ExtensionDownloadsEventRouterData(download_item, json_item.Pass());
   }
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
-      event_router();
+  EventRouter* router = EventRouter::Get(profile_);
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
   if (download_item->IsTemporary() ||
       !router->HasEventListener(downloads::OnChanged::kEventName)) {
     return;
   }
   if (!data) {
     // The download_item probably transitioned from temporary to not temporary,
     // or else an event listener was added.
     data = new ExtensionDownloadsEventRouterData(
@@ skipping 38 matching lines @@
       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(downloads::OnChanged::kEventName,
                   true,
-                  extensions::Event::WillDispatchCallback(),
+                  Event::WillDispatchCallback(),
                   delta.release());
     data->OnChangedFired();
   }
   data->set_json(new_json.Pass());
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (download_item->IsTemporary())
     return;
-  DispatchEvent(downloads::OnErased::kEventName,
-                true,
-                extensions::Event::WillDispatchCallback(),
-                new base::FundamentalValue(
-                    static_cast<int>(download_item->GetId())));
+  DispatchEvent(
+      downloads::OnErased::kEventName,
+      true,
+      Event::WillDispatchCallback(),
+      new base::FundamentalValue(static_cast<int>(download_item->GetId())));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const std::string& event_name,
     bool include_incognito,
-    const extensions::Event::WillDispatchCallback& will_dispatch_callback,
+    const Event::WillDispatchCallback& will_dispatch_callback,
     base::Value* arg) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!extensions::EventRouter::Get(profile_))
+  if (!EventRouter::Get(profile_))
     return;
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(args.get(), &json_args);
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      event_name, args.Pass()));
+  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
   // The downloads system wants to share on-record events with off-record
   // extension renderers even in incognito_split_mode because that's how
   // chrome://downloads works. The "restrict_to_profile" mechanism does not
   // anticipate this, so it does not automatically prevent sharing off-record
   // events with on-record extension renderers.
   event->restrict_to_browser_context =
       (include_incognito && !profile_->IsOffTheRecord()) ? NULL : profile_;
   event->will_dispatch_callback = will_dispatch_callback;
-  extensions::EventRouter::Get(profile_)->BroadcastEvent(event.Pass());
+  EventRouter::Get(profile_)->BroadcastEvent(event.Pass());
   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));
 }
 
 void ExtensionDownloadsEventRouter::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
-    const extensions::Extension* extension,
-    extensions::UnloadedExtensionInfo::Reason reason) {
+    const Extension* extension,
+    UnloadedExtensionInfo::Reason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  std::set<const extensions::Extension*>::iterator iter =
+  std::set<const Extension*>::iterator iter =
       shelf_disabling_extensions_.find(extension);
   if (iter != shelf_disabling_extensions_.end())
     shelf_disabling_extensions_.erase(iter);
 }
 
 }  // namespace extensions