Move extension notifications to extensions/browser/notification_types.h

extensions/browser/process_manager.cc

 // Copyright 2013 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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager_delegate.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/one_shot_event.h"
 #include "extensions/common/switches.h"
@@ skipping 41 matching lines @@
 
 bool IsFrameInExtensionHost(ExtensionHost* extension_host,
                             content::RenderFrameHost* render_frame_host) {
   return WebContents::FromRenderFrameHost(render_frame_host) ==
       extension_host->host_contents();
 }
 
 void OnRenderViewHostUnregistered(BrowserContext* context,
                                   RenderViewHost* render_view_host) {
   content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
+      extensions::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
       content::Source<BrowserContext>(context),
       content::Details<RenderViewHost>(render_view_host));
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoProcessManager : public ProcessManager {
  public:
   IncognitoProcessManager(BrowserContext* incognito_context,
@@ skipping 133 matching lines @@
                                ExtensionRegistry* extension_registry)
     : site_instance_(SiteInstance::Create(context)),
       extension_registry_(extension_registry),
       startup_background_hosts_created_(false),
       devtools_callback_(base::Bind(&ProcessManager::OnDevToolsStateChanged,
                                     base::Unretained(this))),
       last_background_close_sequence_id_(0),
       weak_ptr_factory_(this) {
   // ExtensionRegistry is shared between incognito and regular contexts.
   DCHECK_EQ(original_context, extension_registry_->browser_context());
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
+  registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
+                 extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+  registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
+  registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<BrowserContext>(context));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
+  registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllSources());
 
   // Note: event_page_idle_time_ must be sufficiently larger (e.g. 2x) than
   // kKeepaliveThrottleIntervalInSeconds in ppapi/proxy/plugin_globals.
   event_page_idle_time_ = base::TimeDelta::FromSeconds(10);
   unsigned idle_time_msec = 0;
@@ skipping 375 matching lines @@
 
 void ProcessManager::SetKeepaliveImpulseDecrementCallbackForTesting(
     const ImpulseCallbackForTesting& callback) {
   keepalive_impulse_decrement_callback_for_testing_ = callback;
 }
 
 void ProcessManager::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSIONS_READY: {
+    case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED: {
       // TODO(jamescook): Convert this to use ExtensionSystem::ready() instead
       // of a notification.
       MaybeCreateStartupBackgroundHosts();
       break;
     }
 
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
+    case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
       BrowserContext* context = content::Source<BrowserContext>(source).ptr();
       ExtensionSystem* system = ExtensionSystem::Get(context);
       if (system->ready().is_signaled()) {
         // The extension system is ready, so create the background host.
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
         CreateBackgroundHostForExtensionLoad(this, extension);
       }
       break;
     }
 
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
+    case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
       const Extension* extension =
           content::Details<UnloadedExtensionInfo>(details)->extension;
       for (ExtensionHostSet::iterator iter = background_hosts_.begin();
            iter != background_hosts_.end(); ++iter) {
         ExtensionHost* host = *iter;
         if (host->extension_id() == extension->id()) {
           CloseBackgroundHost(host);
           break;
         }
       }
       UnregisterExtension(extension->id());
       break;
     }
 
-    case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
+    case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (background_hosts_.erase(host)) {
         ClearBackgroundPageData(host->extension()->id());
         background_page_data_[host->extension()->id()].since_suspended.reset(
             new base::ElapsedTimer());
       }
       break;
     }
 
-    case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
+    case extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (host->extension_host_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         CloseBackgroundHost(host);
       }
       break;
     }
 
     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
       // We get this notification both for new WebContents and when one
       // has its RenderViewHost replaced (e.g. when a user does a cross-site
@@ skipping 23 matching lines @@
       if (contents->GetBrowserContext() != GetBrowserContext())
         break;
       const Extension* extension = GetExtensionForRenderViewHost(
           contents->GetRenderViewHost());
       if (!extension)
         return;
 
       // RegisterRenderViewHost is called too early (before the process is
       // available), so we need to wait until now to notify.
       content::NotificationService::current()->Notify(
-          chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
+          extensions::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
           content::Source<BrowserContext>(GetBrowserContext()),
           content::Details<RenderViewHost>(contents->GetRenderViewHost()));
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
@@ skipping 40 matching lines @@
 
   CreateStartupBackgroundHosts();
   startup_background_hosts_created_ = true;
 
   // Background pages should only be loaded once. To prevent any further loads
   // occurring, we remove the notification listeners.
   BrowserContext* original_context =
       ExtensionsBrowserClient::Get()->GetOriginalContext(GetBrowserContext());
   if (registrar_.IsRegistered(
           this,
-          chrome::NOTIFICATION_EXTENSIONS_READY,
+          extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
           content::Source<BrowserContext>(original_context))) {
     registrar_.Remove(this,
-                      chrome::NOTIFICATION_EXTENSIONS_READY,
+                      extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                       content::Source<BrowserContext>(original_context));
   }
 }
 
 void ProcessManager::CreateStartupBackgroundHosts() {
   DCHECK(!startup_background_hosts_created_);
   const ExtensionSet& enabled_extensions =
       extension_registry_->enabled_extensions();
   for (ExtensionSet::const_iterator extension = enabled_extensions.begin();
        extension != enabled_extensions.end();
@@ skipping 72 matching lines @@
     ProcessManager* original_manager,
     ExtensionRegistry* extension_registry)
     : ProcessManager(incognito_context, original_context, extension_registry),
       original_manager_(original_manager) {
   DCHECK(incognito_context->IsOffTheRecord());
 
   // The original profile will have its own ProcessManager to
   // load the background pages of the spanning extensions. This process
   // manager need only worry about the split mode extensions, which is handled
   // in the NOTIFICATION_BROWSER_WINDOW_READY notification handler.
-  registrar_.Remove(this, chrome::NOTIFICATION_EXTENSIONS_READY,
+  registrar_.Remove(this,
+                    extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                     content::Source<BrowserContext>(original_context));
 }
 
 bool IncognitoProcessManager::CreateBackgroundHost(const Extension* extension,
                                                    const GURL& url) {
   if (IncognitoInfo::IsSplitMode(extension)) {
     if (ExtensionsBrowserClient::Get()->IsExtensionIncognitoEnabled(
             extension->id(), GetBrowserContext()))
       return ProcessManager::CreateBackgroundHost(extension, url);
   } else {
     // Do nothing. If an extension is spanning, then its original-profile
     // background page is shared with incognito, so we don't create another.
   }
   return false;
 }
 
 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
   const Extension* extension =
       extension_registry_->enabled_extensions().GetExtensionOrAppByURL(url);
   if (extension && !IncognitoInfo::IsSplitMode(extension))
     return original_manager_->GetSiteInstanceForURL(url);
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions