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"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 
 using content::BrowserThread;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::SiteInstance;
+using content::WebContents;
 
 namespace {
 
 std::string GetExtensionID(RenderViewHost* render_view_host) {
   // This works for both apps and extensions because the site has been
   // normalized to the extension URL for apps.
   return render_view_host->GetSiteInstance()->GetSite().host();
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
@@ skipping 250 matching lines @@
     ExtensionProcessManager::GetRenderViewHostsForExtension(
         const std::string& extension_id) {
   std::set<RenderViewHost*> result;
 
   SiteInstance* site_instance = GetSiteInstanceForURL(
       Extension::GetBaseURLFromExtensionId(extension_id));
   if (!site_instance)
     return result;
 
   // 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);
+  for (ExtensionWebContents::iterator contents =
+           all_extension_contents_.begin();
+       contents != all_extension_contents_.end(); ++contents) {
+    if (contents->first->GetSiteInstance() == site_instance)
+      result.insert(contents->first->GetRenderViewHost());
   }
 
   return result;
 }
 
-void ExtensionProcessManager::RegisterRenderViewHost(
-    RenderViewHost* render_view_host,
-    const Extension* extension) {
-  all_extension_views_[render_view_host] = content::VIEW_TYPE_INVALID;
+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());
 }
 
-void ExtensionProcessManager::UnregisterRenderViewHost(
-    RenderViewHost* render_view_host) {
-  ExtensionRenderViews::iterator view =
-      all_extension_views_.find(render_view_host);
-  if (view == all_extension_views_.end())
+void ExtensionProcessManager::RegisterWebContents(
+    WebContents* web_contents,
+    const Extension* extension) {
+  all_extension_contents_[web_contents] = content::VIEW_TYPE_INVALID;
+}
+
+void ExtensionProcessManager::UnregisterWebContents(
+    WebContents* web_contents) {
+  ExtensionWebContents::iterator contents =
+      all_extension_contents_.find(web_contents);
+  if (contents == all_extension_contents_.end())
     return;
 
-  content::ViewType view_type = view->second;
-  all_extension_views_.erase(view);
+  content::ViewType view_type = contents->second;
+  all_extension_contents_.erase(contents);
 
   // Keepalive count, balanced in UpdateRegisteredRenderView.
   if (view_type != content::VIEW_TYPE_INVALID &&
       view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension =
         GetProfile()->GetExtensionService()->extensions()->GetByID(
-            GetExtensionID(render_view_host));
+            GetExtensionID(contents->first->GetRenderViewHost()));
     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())
+void ExtensionProcessManager::UpdateRegisteredWebContents(
+    WebContents* web_contents) {
+  ExtensionWebContents::iterator contents =
+      all_extension_contents_.find(web_contents);
+  if (contents == all_extension_contents_.end())
     return;
 
-  view->second = render_view_host->GetDelegate()->GetRenderViewType();
+  RenderViewHost* render_view_host = contents->first->GetRenderViewHost();
+  contents->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) {
+  if (contents->second != content::VIEW_TYPE_INVALID &&
+      contents->second != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension =
         GetProfile()->GetExtensionService()->extensions()->GetByID(
             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();
-}
-
 int ExtensionProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
   return background_page_data_[extension->id()].lazy_keepalive_count;
 }
 
 int ExtensionProcessManager::IncrementLazyKeepaliveCount(
      const Extension* extension) {
   if (!extension->has_lazy_background_page())
@@ skipping 117 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;
     }
 
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED: {
       content::WebContents* contents =
           content::Source<content::WebContents>(source).ptr();
-      UpdateRegisteredRenderView(contents->GetRenderViewHost());
+      UpdateRegisteredWebContents(contents);
       break;
     }
 
     case content::NOTIFICATION_APP_TERMINATING: {
       // Close background hosts when the last browser is closed so that they
       // have time to shutdown various objects on different threads. Our
       // destructor is called too late in the shutdown sequence.
       CloseBackgroundHosts();
       break;
     }
@@ skipping 34 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::ContentsSet
+ExtensionProcessManager::GetAllContents() const {
+  ContentsSet result;
+  for (ExtensionWebContents::const_iterator iter =
+           all_extension_contents_.begin();
+       iter != all_extension_contents_.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;
   }
 }