Send an onInstalled event for shared module update

chrome/browser/extensions/shared_module_service.cc

 // Copyright 2014 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/shared_module_service.h"
 
 #include <vector>
 
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 86 matching lines @@
       pending_extension_manager->AddFromExtensionImport(
           iter->extension_id,
           extension_urls::GetWebstoreUpdateUrl(),
           SharedModuleInfo::IsSharedModule);
     }
     service->CheckForUpdatesSoon();
   }
   return status;
 }
 
-scoped_ptr<const ExtensionSet> SharedModuleService::GetDependentExtensions(
+scoped_ptr<ExtensionSet> SharedModuleService::GetDependentExtensions(
     const Extension* extension) {
   scoped_ptr<ExtensionSet> dependents(new ExtensionSet());
 
   if (SharedModuleInfo::IsSharedModule(extension)) {
     ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
     ExtensionService* service =
         ExtensionSystem::Get(browser_context_)->extension_service();
 
     ExtensionSet set_to_check;
     set_to_check.InsertAll(registry->enabled_extensions());
     set_to_check.InsertAll(registry->disabled_extensions());
     set_to_check.InsertAll(*service->delayed_installs());
 
     for (ExtensionSet::const_iterator iter = set_to_check.begin();
          iter != set_to_check.end();
          ++iter) {
       if (SharedModuleInfo::ImportsExtensionById(iter->get(),
                                                  extension->id())) {
         dependents->Insert(*iter);
       }
     }
   }
-  return dependents.PassAs<const ExtensionSet>();
+  return dependents.PassAs<ExtensionSet>();
 }
 
 void SharedModuleService::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   // Uninstalls shared modules that were only referenced by |extension|.
   if (!SharedModuleInfo::ImportsModules(extension))
     return;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
   ExtensionService* service =
       ExtensionSystem::Get(browser_context_)->extension_service();
 
   const ImportInfoVector& imports = SharedModuleInfo::GetImports(extension);
   for (ImportInfoVector::const_iterator iter = imports.begin();
        iter != imports.end();
        ++iter) {
     const Extension* imported_module =
         registry->GetExtensionById(iter->extension_id,
                                    ExtensionRegistry::EVERYTHING);
     if (imported_module && imported_module->from_webstore()) {
-      scoped_ptr<const ExtensionSet> dependents =
+      scoped_ptr<ExtensionSet> dependents =
           GetDependentExtensions(imported_module);
       if (dependents->is_empty()) {
         service->UninstallExtension(iter->extension_id,
                                     true,  // External uninstall.
                                     NULL);  // Ignore error.
       }
     }
   }
 }
 
 }  // namespace extensions