Reloading page after installing app should bring it into correct process.

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2012 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/renderer/chrome_content_renderer_client.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 605 matching lines @@
   ChromeV8Context* current_context =
       extension_dispatcher_->v8_context_set().GetCurrent();
   return current_context && !current_context->extension_id().empty();
 }
 
 bool ChromeContentRendererClient::ShouldFork(WebFrame* frame,
                                              const GURL& url,
                                              bool is_content_initiated,
                                              bool is_initial_navigation,
                                              bool* send_referrer) {
+  const ExtensionSet* extensions = extension_dispatcher_->extensions();
+
+  // Determine if the new URL is an extension (excluding bookmark apps).
+  const Extension* new_url_extension = extensions::GetNonBookmarkAppExtension(
+      *extensions, ExtensionURLInfo(url));
+  bool is_extension_url = !!new_url_extension;
+
   // If the navigation would cross an app extent boundary, we also need
   // to defer to the browser to ensure process isolation.
   // TODO(erikkay) This is happening inside of a check to is_content_initiated
   // which means that things like the back button won't trigger it.  Is that
   // OK?
-  if (CrossesExtensionExtents(frame, url, is_initial_navigation)) {
+  if (CrossesExtensionExtents(frame, url, *extensions, is_extension_url,
+          is_initial_navigation)) {
     // Include the referrer in this case since we're going from a hosted web
     // page. (the packaged case is handled previously by the extension
     // navigation test)
     *send_referrer = true;
 
     if (is_content_initiated) {
       const Extension* extension =
           extension_dispatcher_->extensions()->GetExtensionOrAppByURL(
               ExtensionURLInfo(url));
       if (extension && extension->is_app()) {
         UMA_HISTOGRAM_ENUMERATION(
             extension_misc::kAppLaunchHistogram,
             extension_misc::APP_LAUNCH_CONTENT_NAVIGATION,
             extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
       }
     }
     return true;
   }
 
+  // If this is a reload, check whether it has the wrong process type.  We
+  // should send it to the browser if it's an extension URL (e.g., hosted app)
+  // in a normal process, or if it's a process for an extension that has been
+  // uninstalled.
+  if (frame->top()->document().url() == url) {
+    if (is_extension_url != extension_dispatcher_->is_extension_process())
+      return true;
+  }
+
   // Navigating to a new chrome:// scheme (in a new tab) from within a
   // chrome:// page must be a browser navigation so that the browser can
   // register the new associated data source.
   if (is_content_initiated && url.SchemeIs(kChromeUIScheme))
     return true;
 
   return false;
 }
 
 bool ChromeContentRendererClient::WillSendRequest(WebKit::WebFrame* frame,
@@ skipping 83 matching lines @@
 }
 
 void ChromeContentRendererClient::SetExtensionDispatcher(
     ExtensionDispatcher* extension_dispatcher) {
   extension_dispatcher_.reset(extension_dispatcher);
 }
 
 bool ChromeContentRendererClient::CrossesExtensionExtents(
     WebFrame* frame,
     const GURL& new_url,
+    const ExtensionSet& extensions,
+    bool is_extension_url,
     bool is_initial_navigation) {
-  const ExtensionSet* extensions = extension_dispatcher_->extensions();
   GURL old_url(frame->top()->document().url());
 
-  // Determine if the new URL is an extension (excluding bookmark apps).
-  const Extension* new_url_extension = extensions::GetNonBookmarkAppExtension(
-      *extensions, ExtensionURLInfo(new_url));
-
   // If old_url is still empty and this is an initial navigation, then this is
   // a window.open operation.  We should look at the opener URL.
   if (is_initial_navigation && old_url.is_empty() && frame->opener()) {
     // If we're about to open a normal web page from a same-origin opener stuck
     // in an extension process, we want to keep it in process to allow the
     // opener to script it.
     WebDocument opener_document = frame->opener()->document();
     GURL opener_url = opener_document.url();
     WebSecurityOrigin opener_origin = opener_document.securityOrigin();
-    bool opener_is_extension_url = !!extensions->GetExtensionOrAppByURL(
+    bool opener_is_extension_url = !!extensions.GetExtensionOrAppByURL(
         ExtensionURLInfo(opener_origin, opener_url));
     WebSecurityOrigin opener = frame->opener()->document().securityOrigin();
-    if (!new_url_extension &&
+    if (!is_extension_url &&
         !opener_is_extension_url &&
         extension_dispatcher_->is_extension_process() &&
         opener.canRequest(WebURL(new_url)))
       return false;
 
     // In all other cases, we want to compare against the top frame's URL (as
     // opposed to the opener frame's), since that's what determines the type of
     // process.  This allows iframes outside an app to open a popup in the app.
     old_url = frame->top()->opener()->top()->document().url();
   }
 
   return extensions::CrossesExtensionProcessBoundary(
-      *extensions, ExtensionURLInfo(old_url), ExtensionURLInfo(new_url));
+      extensions, ExtensionURLInfo(old_url), ExtensionURLInfo(new_url));
 }
 
 void ChromeContentRendererClient::OnPurgeMemory() {
   DVLOG(1) << "Resetting spellcheck in renderer client";
   RenderThread* thread = RenderThread::Get();
   if (spellcheck_.get())
     thread->RemoveObserver(spellcheck_.get());
   spellcheck_.reset(new SpellCheck());
   thread->AddObserver(spellcheck_.get());
 }
@@ skipping 24 matching lines @@
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 bool ChromeContentRendererClient::AllowSocketAPI(const GURL& url) {
   return allowed_socket_origins_.find(url.host()) !=
       allowed_socket_origins_.end();
 }
 
 }  // namespace chrome