Move ExtensionProcessManager to src/extensions, part 3 - remove Browser

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 "chrome/browser/extensions/extension_process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.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/extensions/extension_util.h"
-#include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
-#include "chrome/common/extensions/manifest_url_handler.h"
-#include "chrome/common/url_constants.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_manager.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/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
@@ skipping 42 matching lines @@
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ExtensionProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoExtensionProcessManager : public ExtensionProcessManager {
  public:
   IncognitoExtensionProcessManager(BrowserContext* incognito_context,
                                    BrowserContext* original_context);
   virtual ~IncognitoExtensionProcessManager();
-  virtual ExtensionHost* CreateViewHost(
-      const Extension* extension,
-      const GURL& url,
-      Browser* browser,
-      extensions::ViewType view_type) OVERRIDE;
   virtual ExtensionHost* CreateBackgroundHost(const Extension* extension,
                                               const GURL& url) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
   ExtensionProcessManager* original_manager_;
 
@@ skipping 135 matching lines @@
 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;
 }
 
-void ExtensionProcessManager::EnsureBrowserWhenRequired(
-    Browser* browser,
-    extensions::ViewType view_type) {
-  if (!browser) {
-    // A NULL browser may only be given for pop-up views and dialogs.
-    DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP ||
-           view_type == extensions::VIEW_TYPE_EXTENSION_DIALOG);
-  }
-}
-
-ExtensionHost* ExtensionProcessManager::CreateViewHost(
-    const Extension* extension,
-    const GURL& url,
-    Browser* browser,
-    extensions::ViewType view_type) {
-  DVLOG(1) << "CreateViewHost";
-  DCHECK(extension);
-  EnsureBrowserWhenRequired(browser, view_type);
-  ExtensionHost* host =
-#if defined(OS_MACOSX)
-      new extensions::ExtensionHostMac(
-          extension, GetSiteInstanceForURL(url), url, view_type);
-#else
-      new ExtensionHost(extension, GetSiteInstanceForURL(url), url, view_type);
-#endif
-  host->CreateView(browser);
-  OnExtensionHostCreated(host, false);
-  return host;
-}
-
-ExtensionHost* ExtensionProcessManager::CreateViewHost(
-    const GURL& url, Browser* browser, extensions::ViewType view_type) {
-  EnsureBrowserWhenRequired(browser, view_type);
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      GetBrowserContext())->extension_service();
-  if (service) {
-    std::string extension_id = url.host();
-    if (url.SchemeIs(chrome::kChromeUIScheme) &&
-        url.host() == chrome::kChromeUIExtensionInfoHost)
-      extension_id = url.path().substr(1);
-    const Extension* extension =
-        service->extensions()->GetByID(extension_id);
-    if (extension)
-      return CreateViewHost(extension, url, browser, view_type);
-  }
-  return NULL;
-}
-
-ExtensionHost* ExtensionProcessManager::CreatePopupHost(
-    const Extension* extension, const GURL& url, Browser* browser) {
-  return CreateViewHost(
-      extension, url, browser, extensions::VIEW_TYPE_EXTENSION_POPUP);
-}
-
-ExtensionHost* ExtensionProcessManager::CreatePopupHost(
-    const GURL& url, Browser* browser) {
-  return CreateViewHost(url, browser, extensions::VIEW_TYPE_EXTENSION_POPUP);
-}
-
-ExtensionHost* ExtensionProcessManager::CreateDialogHost(const GURL& url) {
-  return CreateViewHost(url, NULL, extensions::VIEW_TYPE_EXTENSION_DIALOG);
-}
-
-ExtensionHost* ExtensionProcessManager::CreateInfobarHost(
-    const Extension* extension, const GURL& url, Browser* browser) {
-  return CreateViewHost(
-      extension, url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
-}
-
-ExtensionHost* ExtensionProcessManager::CreateInfobarHost(
-    const GURL& url, Browser* browser) {
-  return CreateViewHost(url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
-}
-
 ExtensionHost* ExtensionProcessManager::CreateBackgroundHost(
     const Extension* extension, const GURL& url) {
   DVLOG(1) << "CreateBackgroundHost " << url.spec();
   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
   // here.
   if (extension->is_hosted_app())
     return NULL;
 
   // Don't create multiple background hosts for an extension.
   if (ExtensionHost* host = GetBackgroundHostForExtension(extension->id()))
     return host;  // TODO(kalman): return NULL here? It might break things...
 
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new extensions::ExtensionHostMac(
           extension, GetSiteInstanceForURL(url), url,
           extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 #else
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
                         extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 #endif
 
   host->CreateRenderViewSoon();
-  OnExtensionHostCreated(host, true);
+  OnBackgroundHostCreated(host);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::GetBackgroundHostForExtension(
     const std::string& extension_id) {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ++iter) {
     ExtensionHost* host = *iter;
     if (host->extension_id() == extension_id)
       return host;
@@ skipping 426 matching lines @@
   if (registrar_.IsRegistered(
           this,
           chrome::NOTIFICATION_EXTENSIONS_READY,
           content::Source<BrowserContext>(original_context))) {
     registrar_.Remove(this,
                       chrome::NOTIFICATION_EXTENSIONS_READY,
                       content::Source<BrowserContext>(original_context));
   }
 }
 
-void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
-                                                     bool is_background) {
-  DCHECK_EQ(site_instance_->GetBrowserContext(), host->browser_context());
-  if (is_background) {
-    background_hosts_.insert(host);
+void ExtensionProcessManager::OnBackgroundHostCreated(ExtensionHost* host) {
+  DCHECK_EQ(GetBrowserContext(), host->browser_context());
+  background_hosts_.insert(host);
 
-    if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
-      linked_ptr<base::ElapsedTimer> since_suspended(
-          background_page_data_[host->extension()->id()].
-              since_suspended.release());
-      if (since_suspended.get()) {
-        UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
-                                 since_suspended->Elapsed());
-      }
+  if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
+    linked_ptr<base::ElapsedTimer> since_suspended(
+        background_page_data_[host->extension()->id()].
+            since_suspended.release());
+    if (since_suspended.get()) {
+      UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
+                               since_suspended->Elapsed());
     }
   }
 }
 
 void ExtensionProcessManager::CloseBackgroundHost(ExtensionHost* host) {
   CHECK(host->extension_host_type() ==
         extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   delete host;
   // |host| should deregister itself from our structures.
   CHECK(background_hosts_.find(host) == background_hosts_.end());
@@ skipping 76 matching lines @@
 
 IncognitoExtensionProcessManager::~IncognitoExtensionProcessManager() {
   // TODO(yoz): This cleanup code belongs in the MenuManager.
   // Remove "incognito" "split" mode context menu items.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   if (service)
     service->menu_manager()->RemoveAllIncognitoContextItems();
 }
 
-ExtensionHost* IncognitoExtensionProcessManager::CreateViewHost(
-    const Extension* extension,
-    const GURL& url,
-    Browser* browser,
-    extensions::ViewType view_type) {
-  if (extensions::IncognitoInfo::IsSplitMode(extension)) {
-    if (IsIncognitoEnabled(extension)) {
-      return ExtensionProcessManager::CreateViewHost(extension, url,
-                                                     browser, view_type);
-    } else {
-      NOTREACHED() <<
-          "We shouldn't be trying to create an incognito extension view unless "
-          "it has been enabled for incognito.";
-      return NULL;
-    }
-  } else {
-    return original_manager_->CreateViewHost(extension, url,
-                                             browser, view_type);
-  }
-}
-
 ExtensionHost* IncognitoExtensionProcessManager::CreateBackgroundHost(
     const Extension* extension, const GURL& url) {
   if (extensions::IncognitoInfo::IsSplitMode(extension)) {
     if (IsIncognitoEnabled(extension))
       return ExtensionProcessManager::CreateBackgroundHost(extension, url);
   } else {
     // Do nothing. If an extension is spanning, then its original-profile
     // background page is shared with incognito, so we don't create another.
   }
   return NULL;
@@ skipping 14 matching lines @@
   return ExtensionProcessManager::GetSiteInstanceForURL(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }