Register a Service Worker when an extension is enabled.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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 "chrome/browser/extensions/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 63 matching lines @@
 #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/external_provider_interface.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/browser/runtime_data.h"
+#include "extensions/browser/service_worker_manager.h"
 #include "extensions/browser/update_observer.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
@@ skipping 10 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/extensions/install_limiter.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
+using extensions::BackgroundInfo;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::FeatureSwitch;
 using extensions::InstallVerifier;
 using extensions::ManagementPolicy;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
+using extensions::ServiceWorkerManager;
 using extensions::SharedModuleInfo;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extensions::manifest_errors;
 
 namespace {
 
 // Histogram values for logging events related to externally installed
 // extensions.
 enum ExternalExtensionEvent {
@@ skipping 768 matching lines @@
   if (!extension)
     return;
 
   // The extension is either enabled or terminated.
   DCHECK(registry_->enabled_extensions().Contains(extension->id()) ||
          registry_->terminated_extensions().Contains(extension->id()));
 
   // Move it over to the disabled list. Don't send a second unload notification
   // for terminated extensions being disabled.
   registry_->AddDisabled(make_scoped_refptr(extension));
+
+  if (BackgroundInfo::HasServiceWorker(extension))
+    ServiceWorkerManager::Get(profile_)->UnregisterExtension(extension);
+
   if (registry_->enabled_extensions().Contains(extension->id())) {
     registry_->RemoveEnabled(extension->id());
     NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::REASON_DISABLE);
   } else {
     registry_->RemoveTerminated(extension->id());
   }
 
   if (extension_sync_service_)
     extension_sync_service_->SyncDisableExtension(*extension);
 }
@@ skipping 91 matching lines @@
       if (host_profile->GetOriginalProfile() ==
           profile_->GetOriginalProfile()) {
         std::vector<ExtensionMsg_Loaded_Params> loaded_extensions(
             1, ExtensionMsg_Loaded_Params(extension));
         host->Send(
             new ExtensionMsg_Loaded(loaded_extensions));
       }
     }
   }
 
+  if (BackgroundInfo::HasServiceWorker(extension))
+    ServiceWorkerManager::Get(profile_)->RegisterExtension(extension);
+
   // Tell subsystems that use the EXTENSION_LOADED notification about the new
   // extension.
   //
   // NOTE: It is important that this happen after notifying the renderers about
   // the new extensions so that if we navigate to an extension URL in
   // ExtensionRegistryObserver::OnLoaded or NOTIFICATION_EXTENSION_LOADED, the
   // renderer is guaranteed to know about it.
   registry_->TriggerOnLoaded(extension);
 
   content::NotificationService::current()->Notify(
@@ skipping 468 matching lines @@
     registry_->RemoveDisabled(extension->id());
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     // Don't send the unloaded notification. It was sent when the extension
     // was disabled.
   } else {
     // Remove the extension from the enabled list.
     registry_->RemoveEnabled(extension->id());
+
+    if (BackgroundInfo::HasServiceWorker(extension)) {
+      switch (reason) {
+        case UnloadedExtensionInfo::REASON_DISABLE:
+        case UnloadedExtensionInfo::REASON_UNINSTALL:
+        case UnloadedExtensionInfo::REASON_BLACKLIST:
+          ServiceWorkerManager::Get(profile_)->UnregisterExtension(extension);
+          break;
+        case UnloadedExtensionInfo::REASON_UPDATE:
+        case UnloadedExtensionInfo::REASON_TERMINATE:
+          break;
+      }
+    }
     NotifyExtensionUnloaded(extension.get(), reason);
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_REMOVED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension.get()));
 }
 
 void ExtensionService::RemoveComponentExtension(
@@ skipping 1136 matching lines @@
 void ExtensionService::UnloadAllExtensionsInternal() {
   profile_->GetExtensionSpecialStoragePolicy()->RevokeRightsForAllExtensions();
 
   registry_->ClearAll();
   system_->runtime_data()->ClearAll();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled.
 }