Pull shell window stuff out of ExtensionHost and put in ShellWindow

chrome/browser/extensions/extension_process_manager.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
@@ skipping 134 matching lines @@
                  content::Source<content::BrowserContext>(profile));
   registrar_.Add(this, content::NOTIFICATION_DEVTOOLS_WINDOW_CLOSING,
                  content::Source<content::BrowserContext>(profile));
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
 
-ExtensionHost* ExtensionProcessManager::CreateShellHost(
-    const Extension* extension,
-    const GURL& url) {
-  DCHECK(extension);
-  ExtensionHost* host = new ExtensionHost(extension,
-                                          GetSiteInstanceForURL(url),
-                                          url,
-                                          chrome::VIEW_TYPE_APP_SHELL);
-  host->CreateViewWithoutBrowser();
-  content::WebContents* host_contents = host->host_contents();
-  host_contents->GetMutableRendererPrefs()->browser_handles_all_requests = true;
-  host_contents->GetRenderViewHost()->SyncRendererPrefs();
-  OnExtensionHostCreated(host, false /* not a background host */);
-  return host;
-}
-
 void ExtensionProcessManager::EnsureBrowserWhenRequired(
     Browser* browser,
     content::ViewType view_type) {
   if (!browser) {
 #if defined (OS_CHROMEOS)
   // On ChromeOS we'll only use ExtensionView, which
   // does not use the browser parameter.
   // TODO(rkc): Remove all this once we create a new host for
   // screensaver extensions (crosbug.com/28211).
   DCHECK(view_type == chrome::VIEW_TYPE_EXTENSION_POPUP ||
@@ skipping 156 matching lines @@
   all_extension_views_[render_view_host] = content::VIEW_TYPE_INVALID;
 }
 
 void ExtensionProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
+      content::Source<Profile>(GetProfile()),
+      content::Details<RenderViewHost>(render_view_host));

[benwells, 2012/04/26 08:36:33]

This is to keep the task manager from crashing if we close shell Windows while
the task manager is open.

+
   content::ViewType view_type = view->second;
   all_extension_views_.erase(view);
 
   // Keepalive count, balanced in UpdateRegisteredRenderView.
   if (view_type != content::VIEW_TYPE_INVALID &&
       view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
       DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::UpdateRegisteredRenderView(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
+      content::Source<Profile>(GetProfile()),
+      content::Details<RenderViewHost>(render_view_host));
+
   view->second = render_view_host->GetDelegate()->GetRenderViewType();
 
   // Keep the lazy background page alive as long as any non-background-page
   // extension views are visible. Keepalive count balanced in
   // UnregisterRenderViewHost.
   if (view->second != content::VIEW_TYPE_INVALID &&
       view->second != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
@@ skipping 133 matching lines @@
         }
       }
       background_page_data_.erase(extension->id());
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (background_hosts_.erase(host))
         background_page_data_.erase(host->extension()->id());
-      platform_app_hosts_.erase(host);
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (host->extension_host_type() ==
           chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         CloseBackgroundHost(host);
       }
       break;
@@ skipping 50 matching lines @@
 
 Profile* ExtensionProcessManager::GetProfile() const {
   return Profile::FromBrowserContext(site_instance_->GetBrowserContext());
 }
 
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
   DCHECK_EQ(site_instance_->GetBrowserContext(), host->profile());
   if (is_background)
     background_hosts_.insert(host);
-  if (host->extension()->is_platform_app())
-    platform_app_hosts_.insert(host);
 }
 
 void ExtensionProcessManager::CloseBackgroundHost(ExtensionHost* host) {
   CHECK(host->extension_host_type() ==
         chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   delete host;
   // |host| should deregister itself from our structures.
   CHECK(background_hosts_.find(host) == background_hosts_.end());
 }
 
@@ skipping 100 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }