Tie extension/app initialization to RenderView creation, not RenderViewHost creation

chrome/browser/renderer_host/chrome_render_view_host_observer.cc

 // Copyright (c) 2011 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/renderer_host/chrome_render_view_host_observer.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/dom_operation_notification_details.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/net/predictor_api.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/render_messages.h"
+#include "content/browser/browsing_instance.h"
+#include "content/browser/child_process_security_policy.h"
+#include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/renderer_host/render_view_host_delegate.h"
-#include "chrome/common/chrome_notification_types.h"
+#include "content/browser/site_instance.h"
 #include "content/common/notification_service.h"
 #include "content/common/url_constants.h"
 #include "content/common/view_messages.h"
 
 ChromeRenderViewHostObserver::ChromeRenderViewHostObserver(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host) {
 }
 
 ChromeRenderViewHostObserver::~ChromeRenderViewHostObserver() {
 }
 
+void ChromeRenderViewHostObserver::RenderViewHostInitialized() {
+  InitRenderViewHostForExtensions();
+}
+
+void ChromeRenderViewHostObserver::InitRenderViewHostForExtensions() {
+  // Note that due to GetEffectiveURL(), even hosted apps will have a

[Charlie Reis, 2011/08/11 19:10:55]

A little unfortunate that we're duplicating the code from here to line 55, plus
some of the "if" blocks below.  We've had bugs in this before and it'd be nice
not to track down new ones in both places.

I wonder if it's better to move it all here and out of
ChromeContentBrowserClient, and then only do the three one-time-init actions
(mark_is_extension_process, RegisterExtensionSiteInstance, and AllowBindings) if
the RenderViewHost isn't yet initialized.  Or do those actions need to be done
earlier?

+  // chrome-extension:// URL for their site, so we can ignore that wrinkle here.
+  SiteInstance* site_instance = render_view_host()->site_instance();
+  const GURL& site = site_instance->site();
+
+  if (!site.SchemeIs(chrome::kExtensionScheme))
+    return;
+
+  Profile* profile = Profile::FromBrowserContext(
+      site_instance->browsing_instance()->browser_context());
+  ExtensionService* service = profile->GetExtensionService();
+  if (!service)
+    return;
+
+  // This can happen if somebody typos a chrome-extension:// URL.
+  const Extension* extension = service->GetExtensionByURL(site);
+  if (!extension)
+    return;
+
+  RenderProcessHost* process = render_view_host()->process();
+
+  if (extension->is_app()) {
+    Send(new ExtensionMsg_ActivateApplication(extension->id()));
+    // Record which, if any, installed app is associated with this process.
+    // TODO(aa): Totally lame to store this state in a global map in extension
+    // service. Can we get it from EPM instead?
+    service->SetInstalledAppForRenderer(process->id(), extension);
+  }
+
+  // Some extensions use chrome:// URLs.
+  Extension::Type type = extension->GetType();
+  if (type == Extension::TYPE_EXTENSION ||
+      type == Extension::TYPE_PACKAGED_APP) {
+    ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
+        process->id(), chrome::kChromeUIScheme);
+  }
+
+  if (type == Extension::TYPE_EXTENSION ||
+      type == Extension::TYPE_USER_SCRIPT ||
+      type == Extension::TYPE_PACKAGED_APP ||
+      (type == Extension::TYPE_HOSTED_APP &&
+       extension->location() == Extension::COMPONENT)) {
+    Send(new ExtensionMsg_ActivateExtension(extension->id()));
+  }
+}
+
 void ChromeRenderViewHostObserver::Navigate(
     const ViewMsg_Navigate_Params& params) {
   const GURL& url = params.url;
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame) &&
       (url.SchemeIs(chrome::kHttpScheme) || url.SchemeIs(chrome::kHttpsScheme)))
     chrome_browser_net::PreconnectUrlAndSubresources(url);
 }
 
 bool ChromeRenderViewHostObserver::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeRenderViewHostObserver, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DomOperationResponse,
                         OnDomOperationResponse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ChromeRenderViewHostObserver::OnDomOperationResponse(
     const std::string& json_string, int automation_id) {
   DomOperationNotificationDetails details(json_string, automation_id);
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
       Source<RenderViewHost>(render_view_host()),
       Details<DomOperationNotificationDetails>(&details));
 }