Remove EPM:all_hosts_ and use all_extension_views_ instead.

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"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 286 matching lines @@
   // Gather up all the views for that site.
   for (ExtensionRenderViews::iterator view = all_extension_views_.begin();
        view != all_extension_views_.end(); ++view) {
     if (view->first->GetSiteInstance() == site_instance)
       result.insert(view->first);
   }
 
   return result;
 }
 
+const Extension* ExtensionProcessManager::GetExtensionForRenderViewHost(
+    content::RenderViewHost* render_view_host) {
+  ExtensionService* service =
+      ExtensionSystem::Get(GetProfile())->extension_service();
+  return service->extensions()->GetByID(
+      render_view_host->GetSiteInstance()->GetSite().host());

[Charlie Reis, 2012/04/23 20:21:49]

I think this is correct for extensions.  A SiteInstance's site isn't always the
same as the URL being shown, but that only really applies to normal pages.  For
extensions, the SiteInstance's site is always valid.

I'm not sure how careful callers of this are, but it is possible for a
RenderViewHost to have a null SiteInstance, and for a SiteInstance to not yet
have a site (see HasSite()).  Only really matters if you pass in RenderViewHosts
that might not be showing extensions.

[benwells, 2012/04/24 04:31:27]

OK, SiteInstance is checked here and in GetExtensionID above. Note that HasSite
is private. It shouldn't matter, if HasSite is false GetSite will return an
empty URL which won't resolve to any extension.

+}
+
 void ExtensionProcessManager::RegisterRenderViewHost(
     RenderViewHost* render_view_host,
     const Extension* extension) {
   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);
@@ skipping 33 matching lines @@
             GetExtensionID(render_view_host));
     if (extension)
       IncrementLazyKeepaliveCount(extension);
   }
 }
 
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
   return site_instance_->GetRelatedSiteInstance(url);
 }
 
-bool ExtensionProcessManager::HasExtensionHost(ExtensionHost* host) const {
-  return all_hosts_.find(host) != all_hosts_.end();
-}
-
 bool ExtensionProcessManager::IsBackgroundHostClosing(
     const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   return (host && background_page_data_[extension_id].is_closing);
 }
 
 int ExtensionProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
@@ skipping 118 matching lines @@
           CloseBackgroundHost(host);
           break;
         }
       }
       background_page_data_.erase(extension->id());
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
-      all_hosts_.erase(host);
       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());
-
-  all_hosts_.insert(host);
   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 13 matching lines @@
     Profile* profile)
     : ExtensionProcessManager(profile),
       original_manager_(profile->GetOriginalProfile()->
                             GetExtensionProcessManager()) {
   DCHECK(profile->IsOffTheRecord());
 
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllSources());
 }
 
+const ExtensionProcessManager::ViewSet
+ExtensionProcessManager::GetAllViews() const {
+  ViewSet result;
+  for (ExtensionRenderViews::const_iterator iter =
+           all_extension_views_.begin();
+       iter != all_extension_views_.end(); ++iter) {
+    result.insert(iter->first);
+  }
+  return result;
+}
+
 ExtensionHost* IncognitoExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
     content::ViewType view_type) {
   if (extension->incognito_split_mode()) {
     if (IsIncognitoEnabled(extension)) {
       return ExtensionProcessManager::CreateViewHost(extension, url,
                                                      browser, view_type);
     } else {
@@ skipping 56 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }