Move ExtensionsProcessManager to src/extensions, part 2

chrome/browser/extensions/extension_process_manager.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/extension_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 "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_util.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_manager.h"
@@ skipping 58 matching lines @@
   virtual ExtensionHost* CreateViewHost(
       const Extension* extension,
       const GURL& url,
       Browser* browser,
       extensions::ViewType view_type) OVERRIDE;
   virtual ExtensionHost* CreateBackgroundHost(const Extension* extension,
                                               const GURL& url) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
-  // content::NotificationObserver:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
-
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
   ExtensionProcessManager* original_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(IncognitoExtensionProcessManager);
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ExtensionProcessManager* manager, const Extension* extension) {
   DVLOG(1) << "CreateBackgroundHostForExtensionLoad";
   if (BackgroundInfo::HasPersistentBackgroundPage(extension))
     manager->CreateBackgroundHost(extension,
                                   BackgroundInfo::GetBackgroundURL(extension));
 }
 
 }  // namespace
 
 class RenderViewHostDestructionObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<RenderViewHostDestructionObserver> {
  public:
   virtual ~RenderViewHostDestructionObserver() {}
 
  private:
   explicit RenderViewHostDestructionObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents) {
-    Profile* profile =
-        Profile::FromBrowserContext(web_contents->GetBrowserContext());
+    BrowserContext* context = web_contents->GetBrowserContext();
     process_manager_ =
-        extensions::ExtensionSystem::Get(profile)->process_manager();
+        ExtensionSystem::GetForBrowserContext(context)->process_manager();
   }
 
   friend class content::WebContentsUserData<RenderViewHostDestructionObserver>;
 
   // content::WebContentsObserver overrides.
   virtual void RenderViewDeleted(RenderViewHost* render_view_host) OVERRIDE {
     process_manager_->UnregisterRenderViewHost(render_view_host);
   }
 
   ExtensionProcessManager* process_manager_;
@@ skipping 35 matching lines @@
     return new IncognitoExtensionProcessManager(context, original_context);
   }
   return new ExtensionProcessManager(context, context);
 }
 
 ExtensionProcessManager::ExtensionProcessManager(
     BrowserContext* context,
     BrowserContext* original_context)
   : site_instance_(SiteInstance::Create(context)),
     defer_background_host_creation_(false),
+    startup_background_hosts_created_(false),
     devtools_callback_(base::Bind(
         &ExtensionProcessManager::OnDevToolsStateChanged,
         base::Unretained(this))),
     weak_ptr_factory_(this) {
-  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
-                 content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  content::Source<BrowserContext>(context));
@@ skipping 388 matching lines @@
 void ExtensionProcessManager::DeferBackgroundHostCreation(bool defer) {
   bool previous = defer_background_host_creation_;
   defer_background_host_creation_ = defer;
 
   // If we were deferred, and we switch to non-deferred, then create the
   // background hosts.
   if (previous && !defer_background_host_creation_)
     CreateBackgroundHostsForProfileStartup();
 }
 
+void ExtensionProcessManager::OnBrowserWindowReady() {
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
+  // On Chrome OS, a login screen is implemented as a browser.
+  // This browser has no extension service.  In this case,
+  // service will be NULL.
+  if (!service || !service->is_ready())
+    return;
+
+  CreateBackgroundHostsForProfileStartup();
+}
+
+content::BrowserContext* ExtensionProcessManager::GetBrowserContext() const {
+  return site_instance_->GetBrowserContext();
+}
+
 void ExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
-      // If a window for this profile, or this profile's incognito profile,
-      // has been opened, make sure this profile's background hosts have
-      // been loaded.
-      Browser* browser = content::Source<Browser>(source).ptr();
-      if (browser->profile() != GetProfile() &&
-          !(GetProfile()->HasOffTheRecordProfile() &&
-            browser->profile() == GetProfile()->GetOffTheRecordProfile()))
-        break;
-
-      ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-          GetBrowserContext())->extension_service();
-      if (!service || !service->is_ready())
-        break;
-
-      CreateBackgroundHostsForProfileStartup();
-      break;
-    }
     case chrome::NOTIFICATION_EXTENSIONS_READY:
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       CreateBackgroundHostsForProfileStartup();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
-      Profile* profile = content::Source<Profile>(source).ptr();
+      BrowserContext* context = content::Source<BrowserContext>(source).ptr();
       ExtensionService* service =
-          extensions::ExtensionSystem::Get(profile)->extension_service();
+          ExtensionSystem::GetForBrowserContext(context)->extension_service();
       if (service->is_ready()) {
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
         CreateBackgroundHostForExtensionLoad(this, extension);
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const Extension* extension =
@@ skipping 101 matching lines @@
   if (attached) {
     // Keep the lazy background page alive while it's being inspected.
     CancelSuspend(extension);
     IncrementLazyKeepaliveCount(extension);
   } else {
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::CreateBackgroundHostsForProfileStartup() {
-  DVLOG(1) << "CreateBackgroundHostsForProfileStartup";
+  if (startup_background_hosts_created_)
+    return;
+
   // Don't load background hosts now if the loading should be deferred.
   // Instead they will be loaded when a browser window for this profile
   // (or an incognito profile from this profile) is ready, or when
   // DeferBackgroundHostCreation is called with false.
   if (DeferLoadingBackgroundHosts())
     return;
 
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   DCHECK(service);
   for (ExtensionSet::const_iterator extension = service->extensions()->begin();
        extension != service->extensions()->end(); ++extension) {
     CreateBackgroundHostForExtensionLoad(this, extension->get());
 
     extensions::RuntimeEventRouter::DispatchOnStartupEvent(
         GetBrowserContext(), (*extension)->id());
   }
+  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());
-  registrar_.Remove(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
-                    content::NotificationService::AllSources());
   if (registrar_.IsRegistered(
           this,
           chrome::NOTIFICATION_PROFILE_CREATED,
           content::Source<BrowserContext>(original_context))) {
     registrar_.Remove(this,
                       chrome::NOTIFICATION_PROFILE_CREATED,
                       content::Source<BrowserContext>(original_context));
   }
   if (registrar_.IsRegistered(
           this,
           chrome::NOTIFICATION_EXTENSIONS_READY,
           content::Source<BrowserContext>(original_context))) {
     registrar_.Remove(this,
                       chrome::NOTIFICATION_EXTENSIONS_READY,
                       content::Source<BrowserContext>(original_context));
   }
 }
 
-Profile* ExtensionProcessManager::GetProfile() const {
-  return Profile::FromBrowserContext(site_instance_->GetBrowserContext());
-}
-
-content::BrowserContext* ExtensionProcessManager::GetBrowserContext() const {
-  return site_instance_->GetBrowserContext();
-}
-
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
   DCHECK_EQ(site_instance_->GetBrowserContext(), host->browser_context());
   if (is_background) {
     background_hosts_.insert(host);
 
     if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
       linked_ptr<base::ElapsedTimer> since_suspended(
           background_page_data_[host->extension()->id()].
               since_suspended.release());
@@ skipping 145 matching lines @@
   return ExtensionProcessManager::GetSiteInstanceForURL(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }
-
-void IncognitoExtensionProcessManager::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  switch (type) {
-    // Do not use ExtensionProcessManager's handler for
-    // NOTIFICATION_BROWSER_WINDOW_READY.
-    case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
-      // We want to spawn our background hosts as soon as the user opens an
-      // incognito window. Watch for new browsers and create the hosts if
-      // it matches our profile.
-      Browser* browser = content::Source<Browser>(source).ptr();
-      if (browser->profile() == site_instance_->GetBrowserContext()) {
-        // On Chrome OS, a login screen is implemented as a browser.
-        // This browser has no extension service.  In this case,
-        // service will be NULL.
-        ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-            GetBrowserContext())->extension_service();
-        if (service && service->is_ready())
-          CreateBackgroundHostsForProfileStartup();
-      }
-      break;
-    }
-    default:
-      ExtensionProcessManager::Observe(type, source, details);
-      break;
-  }
-}