Prune shared extendion module after extension updating.

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 <set>
 #include <vector>
 
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 
@@ skipping 106 matching lines @@
          ++iter) {
       if (SharedModuleInfo::ImportsExtensionById(iter->get(),
                                                  extension->id())) {
         dependents->Insert(*iter);
       }
     }
   }
   return dependents.PassAs<ExtensionSet>();
 }
 
+void SharedModuleService::PruneSharedModules() {
+  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());
+
+  std::vector<std::string> shared_modules;
+  std::set<std::string> used_shared_modules;
+
+  for (ExtensionSet::const_iterator iter = set_to_check.begin();
+       iter != set_to_check.end();
+       ++iter) {
+    if (SharedModuleInfo::IsSharedModule(iter->get()))
+      shared_modules.push_back(iter->get()->id());
+
+    const ImportInfoVector& imports = SharedModuleInfo::GetImports(iter->get());
+    for (ImportInfoVector::const_iterator imports_iter = imports.begin();
+         imports_iter != imports.end();
+         ++imports_iter) {
+      used_shared_modules.insert(imports_iter->extension_id);
+    }
+  }
+
+  std::vector<std::string>::const_iterator shared_modules_iter;
+  for (shared_modules_iter = shared_modules.begin();
+       shared_modules_iter != shared_modules.end();
+       shared_modules_iter++) {
+    if (used_shared_modules.count(*shared_modules_iter))
+      continue;
+    service->UninstallExtension(
+        *shared_modules_iter,
+        ExtensionService::UNINSTALL_REASON_ORPHANED_SHARED_MODULE,
+        NULL);  // Ignore error.
+  }
+}
+
+void SharedModuleService::OnExtensionInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update) {
+  if (is_update)
+    PruneSharedModules();
+}
+
 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<ExtensionSet> dependents =
-          GetDependentExtensions(imported_module);
-      if (dependents->is_empty()) {
-        service->UninstallExtension(
-            iter->extension_id,
-            ExtensionService::UNINSTALL_REASON_ORPHANED_SHARED_MODULE,
-            NULL);  // Ignore error.
-      }
-    }
-  }
+  PruneSharedModules();
 }
 
 }  // namespace extensions