Use ExtensionRegistry in developer private api

chrome/browser/extensions/api/developer_private/developer_private_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/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
@@ skipping 123 matching lines @@
   return GetImageURLFromData(contents);
 }
 
 std::string GetExtensionID(const RenderViewHost* render_view_host) {
   if (!render_view_host->GetSiteInstance())
     return std::string();
 
   return render_view_host->GetSiteInstance()->GetSiteURL().host();
 }
 
+void BroadcastItemStateChanged(content::BrowserContext* browser_context,
+                               developer::EventType event_type,
+                               const std::string& item_id) {
+  developer::EventData event_data;
+  event_data.event_type = event_type;
+  event_data.item_id = item_id;
+
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(event_data.ToValue().release());
+  scoped_ptr<Event> event(new Event(
+      developer_private::OnItemStateChanged::kEventName, args.Pass()));
+  EventRouter::Get(browser_context)->BroadcastEvent(event.Pass());
+}
+
 }  // namespace
 
 namespace AllowFileAccess = api::developer_private::AllowFileAccess;
 namespace AllowIncognito = api::developer_private::AllowIncognito;
 namespace ChoosePath = api::developer_private::ChoosePath;
 namespace Enable = api::developer_private::Enable;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace Inspect = api::developer_private::Inspect;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
@@ skipping 12 matching lines @@
     content::BrowserContext* context) {
   return GetFactoryInstance()->Get(context);
 }
 
 DeveloperPrivateAPI::DeveloperPrivateAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   RegisterNotifications();
 }
 
 DeveloperPrivateEventRouter::DeveloperPrivateEventRouter(Profile* profile)
-    : profile_(profile) {
-  int types[] = {chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
-                 chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
-                 chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+    : extension_registry_observer_(this), profile_(profile) {
+  registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
-                 chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED};
+                 content::Source<Profile>(profile_));
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
+                 content::Source<Profile>(profile_));
 
-  CHECK(registrar_.IsEmpty());
-  for (size_t i = 0; i < arraysize(types); ++i) {
-    registrar_.Add(this,
-                   types[i],
-                   content::Source<Profile>(profile_));
-  }
+  // TODO(limasdf): Use scoped_observer instead.
+  ErrorConsole::Get(profile)->AddObserver(this);
 
-  ErrorConsole::Get(profile)->AddObserver(this);
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 }
 
 DeveloperPrivateEventRouter::~DeveloperPrivateEventRouter() {
   ErrorConsole::Get(profile_)->RemoveObserver(this);
 }
 
 void DeveloperPrivateEventRouter::AddExtensionId(
     const std::string& extension_id) {
   extension_ids_.insert(extension_id);
 }
 
 void DeveloperPrivateEventRouter::RemoveExtensionId(
     const std::string& extension_id) {
   extension_ids_.erase(extension_id);
 }
 
 void DeveloperPrivateEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  const char* event_name = NULL;
   Profile* profile = content::Source<Profile>(source).ptr();
   CHECK(profile);
   CHECK(profile_->IsSameProfile(profile));
   developer::EventData event_data;
-  const Extension* extension = NULL;
 
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED:
-      event_data.event_type = developer::EVENT_TYPE_INSTALLED;
-      extension =
-          content::Details<const InstalledExtensionInfo>(details)->extension;
-      break;
-    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED:
-      event_data.event_type = developer::EVENT_TYPE_UNINSTALLED;
-      extension = content::Details<const Extension>(details).ptr();
-      break;
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
-      event_data.event_type = developer::EVENT_TYPE_LOADED;
-      extension = content::Details<const Extension>(details).ptr();
-      break;
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
-      event_data.event_type = developer::EVENT_TYPE_UNLOADED;
-      extension =
-          content::Details<const UnloadedExtensionInfo>(details)->extension;
-      break;
-    case chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED:
+    case chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED: {
       event_data.event_type = developer::EVENT_TYPE_VIEW_UNREGISTERED;
       event_data.item_id = GetExtensionID(
           content::Details<const RenderViewHost>(details).ptr());
       break;
-    case chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED:
+    }
+    case chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED: {
       event_data.event_type = developer::EVENT_TYPE_VIEW_REGISTERED;
       event_data.item_id = GetExtensionID(
           content::Details<const RenderViewHost>(details).ptr());
       break;
+    }
     default:
       NOTREACHED();
       return;
   }
 
-  if (extension)
-    event_data.item_id = extension->id();
+  BroadcastItemStateChanged(profile, event_data.event_type, event_data.item_id);
+}
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(event_data.ToValue().release());
+void DeveloperPrivateEventRouter::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  DCHECK(profile_->IsSameProfile(Profile::FromBrowserContext(browser_context)));
+  BroadcastItemStateChanged(
+      browser_context, developer::EVENT_TYPE_LOADED, extension->id());
+}
 
-  event_name = developer_private::OnItemStateChanged::kEventName;
-  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
-  EventRouter::Get(profile)->BroadcastEvent(event.Pass());
+void DeveloperPrivateEventRouter::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    UnloadedExtensionInfo::Reason reason) {
+  DCHECK(profile_->IsSameProfile(Profile::FromBrowserContext(browser_context)));
+  BroadcastItemStateChanged(
+      browser_context, developer::EVENT_TYPE_UNLOADED, extension->id());
+}
+
+void DeveloperPrivateEventRouter::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    bool from_ephemeral,
+    const std::string& old_name) {
+  DCHECK(profile_->IsSameProfile(Profile::FromBrowserContext(browser_context)));
+  BroadcastItemStateChanged(
+      browser_context, developer::EVENT_TYPE_INSTALLED, extension->id());
+}
+
+void DeveloperPrivateEventRouter::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  DCHECK(profile_->IsSameProfile(Profile::FromBrowserContext(browser_context)));
+  BroadcastItemStateChanged(
+      browser_context, developer::EVENT_TYPE_UNINSTALLED, extension->id());
 }
 
 void DeveloperPrivateEventRouter::OnErrorAdded(const ExtensionError* error) {
   // We don't want to handle errors thrown by extensions subscribed to these
   // events (currently only the Apps Developer Tool), because doing so risks
   // entering a loop.
   if (extension_ids_.find(error->extension_id()) != extension_ids_.end())
     return;
 
-  developer::EventData event_data;
-  event_data.event_type = developer::EVENT_TYPE_ERROR_ADDED;
-  event_data.item_id = error->extension_id();
-
-  scoped_ptr<base::ListValue> args(new base::ListValue);
-  args->Append(event_data.ToValue().release());
-
-  EventRouter::Get(profile_)->BroadcastEvent(scoped_ptr<Event>(new Event(
-      developer_private::OnItemStateChanged::kEventName, args.Pass())));
+  BroadcastItemStateChanged(
+      profile_, developer::EVENT_TYPE_ERROR_ADDED, error->extension_id());
 }
 
 void DeveloperPrivateAPI::SetLastUnpackedDirectory(const base::FilePath& path) {
   last_unpacked_directory_ = path;
 }
 
 void DeveloperPrivateAPI::RegisterNotifications() {
   EventRouter::Get(profile_)->RegisterObserver(
       this, developer_private::OnItemStateChanged::kEventName);
 }
@@ skipping 1069 matching lines @@
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions