Add service registration for Mojo services defined under chrome/

extensions/browser/extension_web_contents_observer.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/extension_web_contents_observer.h"
 
 #include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/mojo/service_registration.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_messages.h"
 
 namespace extensions {
+namespace {
+
+const Extension* GetExtensionForRenderFrame(

[mark a. foltz, 2015/03/27 20:24:11]

Is there no other way to map the render_frame_host to the extension?  Should the
creator of the observer be able to get a ptr to the Extension being observed?

[Kevin M, 2015/03/27 22:42:37]

I don't think so... the creator of the observer doesn't have the ability to push
additional parameters through to the constructor (the constructor is triggered
indirectly, through a templatized factory method, which only takes a single
WebContents parameter).

The creator could potentially pull the observer back out by accessing it via its
user data key, and then set its extension, but adding an additional dependency
on that userdata key could clutter the code structure.

FWIW, the contents of this method was moved verbatim from
service_registration.cc:
https://code.google.com/p/chromium/codesearch#chromium/src/extensions/browser...

[Sam McNally, 2015/03/31 23:38:51]

I don't think there's a way to do this as a simple lookup. Unless this has
changed recently, the extensions system doesn't really work well with
RenderFrames.

+    content::RenderFrameHost* render_frame_host) {
+  content::SiteInstance* site_instance = render_frame_host->GetSiteInstance();
+  GURL url = render_frame_host->GetLastCommittedURL();
+  if (!url.is_empty()) {
+    if (site_instance->GetSiteURL().GetOrigin() != url.GetOrigin())
+      return nullptr;
+  } else {
+    url = site_instance->GetSiteURL();
+  }
+  content::BrowserContext* browser_context = site_instance->GetBrowserContext();
+  if (!url.SchemeIs(kExtensionScheme))
+    return nullptr;
+
+  return ExtensionRegistry::Get(browser_context)
+      ->enabled_extensions()
+      .GetExtensionOrAppByURL(url);
+}
+
+}  // namespace
 
 ExtensionWebContentsObserver::ExtensionWebContentsObserver(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       browser_context_(web_contents->GetBrowserContext()) {
   NotifyRenderViewType(web_contents->GetRenderViewHost());
 }
 
 ExtensionWebContentsObserver::~ExtensionWebContentsObserver() {}
 
@@ skipping 54 matching lines @@
     case Manifest::TYPE_SHARED_MODULE:
       break;
 
     case Manifest::NUM_LOAD_TYPES:
       NOTREACHED();
   }
 }
 
 void ExtensionWebContentsObserver::RenderFrameCreated(
     content::RenderFrameHost* render_frame_host) {
-  RegisterCoreExtensionServices(render_frame_host);
+  const Extension* extension = GetExtensionForRenderFrame(render_frame_host);
+  if (extension) {
+    RegisterMojoServices(render_frame_host,
+                         GetExtensionForRenderFrame(render_frame_host));
+  }
 }
 
 void ExtensionWebContentsObserver::NotifyRenderViewType(
     content::RenderViewHost* render_view_host) {
   if (render_view_host) {
     render_view_host->Send(new ExtensionMsg_NotifyRenderViewType(
         render_view_host->GetRoutingID(), GetViewType(web_contents())));
   }
 }
 
@@ skipping 16 matching lines @@
   // (excluding bookmark apps) will have a chrome-extension:// URL for their
   // site, so we can ignore that wrinkle here.
   const GURL& site = render_view_host->GetSiteInstance()->GetSiteURL();
 
   if (!site.SchemeIs(kExtensionScheme))
     return std::string();
 
   return site.host();
 }
 
+void ExtensionWebContentsObserver::RegisterMojoServices(
+    content::RenderFrameHost* render_frame_host,
+    const Extension* extension) {
+  DCHECK(render_frame_host);
+  DCHECK(extension);
+
+  RegisterServicesForFrame(render_frame_host, extension);
+}
+
 }  // namespace extensions