Send an onInstalled event for shared module update

extensions/browser/api/runtime/runtime_api.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 "extensions/browser/api/runtime/runtime_api.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/shared_module_service.h"

[elijahtaylor1, 2014/06/05 22:36:45]

these includes are triggering presubmit errors, even though there is another
"chrome/browser" include above.

I need access to the SharedModuleService to figure out what extensions to send
events, any ideas?

The only thing I can think of is to modify InstalledExtensionInfo to include the
dependency information and plumb that through from extensionservice on install
(https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...)
to the runtime_api that gets that notification
(https://code.google.com/p/chromium/codesearch#chromium/src/extensions/browser...)

[asargent_no_longer_on_chrome, 2014/06/06 21:07:01]

The goal is that nothing in src/extensions/ can depend on anything in
src/chrome. It looks like src/extensions/DEPS whitelists
chrome_notification_types.h with a TODO to remove that. 

The right way to approach this is probably to see if we can move
chrome/browser/extensions/shared_module_service.h out of chrome/browser into
extensions/browser. That might mean making it it's own ProfileKeyedService, or
hanging it off the ExtensionSystem. 

If that seems like too big a job to tackle, one possibility would be to just add
an abstract method like "GetDependents" to ExtensionSystem that has a concrete
implementation over in ExtensionSystemImpl in chrome/. 

Another thing to consider: should ExtensionRegistry know about the concept of
shared modules?

[elijahtaylor1, 2014/06/06 21:20:42]

I think I would prefer to do that short term (with maybe a cleanup task to move
shared_module_service out of chrome/).  If it is any more than that, then I will
have to backburner this for a later date, because I was targetting M37 for this
and don't have much time to spend on this.  It's really a nice-to-have for M37.


Does this sound ok?
I don't have familiarity with ExtensionRegistry except briefly while writing
tests.  Can you explain or point to a doc that explains how this fits in?

 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/api/runtime.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
+#include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 
 using content::BrowserContext;
 
 namespace extensions {
 
 namespace runtime = core_api::runtime;
 
 namespace {
 
 const char kNoBackgroundPageError[] = "You do not have a background page.";
 const char kPageLoadError[] = "Background page failed to load.";
+const char kInstallId[] = "id";
 const char kInstallReason[] = "reason";
 const char kInstallReasonChromeUpdate[] = "chrome_update";
 const char kInstallReasonUpdate[] = "update";
 const char kInstallReasonInstall[] = "install";
+const char kInstallReasonSharedModuleUpdate[] = "shared_module_update";
 const char kInstallPreviousVersion[] = "previousVersion";
 const char kInvalidUrlError[] = "Invalid URL.";
 const char kPlatformInfoUnavailable[] = "Platform information unavailable.";
 
 const char kUpdatesDisabledError[] = "Autoupdate is not enabled.";
 
 // A preference key storing the url loaded when an extension is uninstalled.
 const char kUninstallUrl[] = "uninstall_url";
 
 // The name of the directory to be returned by getPackageDirectoryEntry. This
@@ skipping 265 matching lines @@
   } else if (chrome_updated) {
     info->SetString(kInstallReason, kInstallReasonChromeUpdate);
   } else {
     info->SetString(kInstallReason, kInstallReasonInstall);
   }
   DCHECK(system->event_router());
   scoped_ptr<Event> event(
       new Event(runtime::OnInstalled::kEventName, event_args.Pass()));
   system->event_router()->DispatchEventWithLazyListener(extension_id,
                                                         event.Pass());
+
+  if (old_version.IsValid()) {
+    const Extension* extension =
+        ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
+            extension_id);
+    if (SharedModuleInfo::IsSharedModule(extension)) {
+      ExtensionService* service = system->extension_service();
+      DCHECK(service);
+      SharedModuleService* sm_service = service->shared_module_service();
+      DCHECK(sm_service);
+      scoped_ptr<const ExtensionSet> dependents =
+          sm_service->GetDependentExtensions(extension);
+      for (ExtensionSet::const_iterator i = dependents->begin();
+           i != dependents->end();
+           i++) {
+        scoped_ptr<base::ListValue> sm_event_args(new base::ListValue());
+        base::DictionaryValue* sm_info = new base::DictionaryValue();
+        sm_event_args->Append(sm_info);
+        sm_info->SetString(kInstallReason, kInstallReasonSharedModuleUpdate);
+        sm_info->SetString(kInstallPreviousVersion, old_version.GetString());
+        sm_info->SetString(kInstallId, extension_id);
+        scoped_ptr<Event> sm_event(
+            new Event(runtime::OnInstalled::kEventName, sm_event_args.Pass()));
+        system->event_router()->DispatchEventWithLazyListener((*i)->id(),
+                                                              sm_event.Pass());
+      }
+    }
+  }
 }
 
 // static
 void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
     content::BrowserContext* context,
     const std::string& extension_id,
     const base::DictionaryValue* manifest) {
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
@@ skipping 160 matching lines @@
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return RespondNow(OneArgument(dict));
 }
 
 }  // namespace extensions