Register a Service Worker when an extension is enabled.

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"
@@ skipping 81 matching lines @@
 // 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,
                           BrowserContext* original_context,
                           ProcessManager* original_manager);
   virtual ~IncognitoProcessManager() {}
   virtual bool CreateBackgroundHost(const Extension* extension,
-                                    const GURL& url) OVERRIDE;
+                                    const GURL& url,
+                                    const base::Closure& continuation) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
   ProcessManager* original_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(IncognitoProcessManager);
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ProcessManager* manager, const Extension* extension) {
@@ skipping 163 matching lines @@
   ViewSet result;
   for (ExtensionRenderViews::const_iterator iter =
            all_extension_views_.begin();
        iter != all_extension_views_.end(); ++iter) {
     result.insert(iter->first);
   }
   return result;
 }
 
 bool ProcessManager::CreateBackgroundHost(const Extension* extension,
-                                          const GURL& url) {
+                                          const GURL& url,
+                                          const base::Closure& continuation) {
   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
   // here.
   if (extension->is_hosted_app() ||
       !ExtensionsBrowserClient::Get()->
           IsBackgroundPageAllowed(GetBrowserContext())) {
     return false;
   }
 
   // Don't create multiple background hosts for an extension.
-  if (GetBackgroundHostForExtension(extension->id()))
+  if (GetBackgroundHostForExtension(extension->id())) {
+    if (!continuation.is_null())
+      continuation.Run();
     return true;  // TODO(kalman): return false here? It might break things...
+  }
 
   ExtensionHost* host =
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
                         VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
-  host->CreateRenderViewSoon();
+  host->CreateRenderViewSoon(continuation);
   OnBackgroundHostCreated(host);
   return true;
 }
 
 ExtensionHost* ProcessManager::GetBackgroundHostForExtension(
     const std::string& extension_id) {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ++iter) {
     ExtensionHost* host = *iter;
     if (host->extension_id() == extension_id)
@@ skipping 570 matching lines @@
   // 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,
                     content::Source<BrowserContext>(original_context));
   registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_CREATED,
                     content::Source<BrowserContext>(original_context));
 }
 
-bool IncognitoProcessManager::CreateBackgroundHost(const Extension* extension,
-                                                   const GURL& url) {
+bool IncognitoProcessManager::CreateBackgroundHost(
+    const Extension* extension,
+    const GURL& url,
+    const base::Closure& continuation) {
   if (IncognitoInfo::IsSplitMode(extension)) {
     if (ExtensionsBrowserClient::Get()->IsExtensionIncognitoEnabled(
             extension->id(), GetBrowserContext()))
-      return ProcessManager::CreateBackgroundHost(extension, url);
+      return ProcessManager::CreateBackgroundHost(extension, url, continuation);
   } 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) {
   ExtensionRegistry* registry = ExtensionRegistry::Get(GetBrowserContext());
   if (registry) {
     const Extension* extension =
         registry->enabled_extensions().GetExtensionOrAppByURL(url);
     if (extension && !IncognitoInfo::IsSplitMode(extension)) {
       return original_manager_->GetSiteInstanceForURL(url);
     }
   }
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions