Make WebUI objects not derive from WebUI. WebUI objects own the controller. This is the ownership...

chrome/browser/ui/webui/chrome_web_ui_factory.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/ui/webui/chrome_web_ui_factory.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
@@ skipping 67 matching lines @@
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include "chrome/browser/ui/webui/certificate_viewer_ui.h"
 #endif
 
 #if !defined(USE_AURA)
 #include "chrome/browser/ui/webui/input_window_dialog_ui.h"
 #endif
 
 using content::WebContents;
+using content::WebUIController;
 
 namespace {
 
 // A function for creating a new WebUI. The caller owns the return value, which
 // may be NULL (for example, if the URL refers to an non-existent extension).
-typedef WebUI* (*WebUIFactoryFunction)(WebContents* web_contents,
-                                       const GURL& url);
+typedef WebUIController* (*WebUIFactoryFunction)(WebUI* web_ui,
+                                                 const GURL& url);
 
 // Template for defining WebUIFactoryFunction.
 template<class T>
-WebUI* NewWebUI(WebContents* contents, const GURL& url) {
-  return new T(contents);
+WebUIController* NewWebUI(WebUI* web_ui, const GURL& url) {
+  return new T(web_ui);
 }
 
 // Special case for extensions.
 template<>
-WebUI* NewWebUI<ExtensionWebUI>(WebContents* contents, const GURL& url) {
-  return new ExtensionWebUI(contents, url);
+WebUIController* NewWebUI<ExtensionWebUI>(WebUI* web_ui, const GURL& url) {
+  return new ExtensionWebUI(web_ui, url);
 }
 
 // Special case for older about: handlers.
 template<>
-WebUI* NewWebUI<AboutUI>(WebContents* contents, const GURL& url) {
-  return new AboutUI(contents, url.host());
+WebUIController* NewWebUI<AboutUI>(WebUI* web_ui, const GURL& url) {
+  return new AboutUI(web_ui, url.host());
 }
 
 // Only create ExtensionWebUI for URLs that are allowed extension bindings,
 // hosted by actual tabs. If tab_contents has no wrapper, it likely refers
 // to another container type, like an extension background page. If there is
-// no tab_contents (it's not accessible when calling GetWebUIType and related
+// no WebUI (it's not accessible when calling GetWebUIType and related
 // functions) then we conservatively assume that we need a WebUI.
-bool NeedsExtensionWebUI(WebContents* web_contents,
+bool NeedsExtensionWebUI(WebUI* web_ui,
                          Profile* profile,
                          const GURL& url) {
   ExtensionService* service = profile ? profile->GetExtensionService() : NULL;
   return service && service->ExtensionBindingsAllowed(url) &&
-      (!web_contents ||
-        TabContentsWrapper::GetCurrentWrapperForContents(web_contents));
+      (!web_ui ||
+        TabContentsWrapper::GetCurrentWrapperForContents(
+            web_ui->GetWebContents()));
 }
 
 // Returns a function that can be used to create the right type of WebUI for a
 // tab, based on its URL. Returns NULL if the URL doesn't have WebUI associated
 // with it.
-WebUIFactoryFunction GetWebUIFactoryFunction(WebContents* web_contents,
+WebUIFactoryFunction GetWebUIFactoryFunction(WebUI* web_ui,
                                              Profile* profile,
                                              const GURL& url) {
-  if (NeedsExtensionWebUI(web_contents, profile, url))
+  if (NeedsExtensionWebUI(web_ui, profile, url))
     return &NewWebUI<ExtensionWebUI>;
 
   // This will get called a lot to check all URLs, so do a quick check of other
   // schemes to filter out most URLs.
   if (!url.SchemeIs(chrome::kChromeDevToolsScheme) &&
       !url.SchemeIs(chrome::kChromeInternalScheme) &&
       !url.SchemeIs(chrome::kChromeUIScheme)) {
     return NULL;
   }
 
@@ skipping 243 matching lines @@
       // It's possible to load about:blank in a Web UI renderer.
       // See http://crbug.com/42547
       url.spec() == chrome::kAboutBlankURL ||
       // Chrome URLs crash, kill, hang, and shorthang are allowed.
       url == GURL(chrome::kChromeUICrashURL) ||
       url == GURL(chrome::kChromeUIKillURL) ||
       url == GURL(chrome::kChromeUIHangURL) ||
       url == GURL(chrome::kChromeUIShorthangURL);
 }
 
-WebUI* ChromeWebUIFactory::CreateWebUIForURL(
-    content::WebContents* web_contents,
+WebUIController* ChromeWebUIFactory::CreateWebUIForURL(
+    WebUI* web_ui,
     const GURL& url) const {
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  WebUIFactoryFunction function = GetWebUIFactoryFunction(web_contents,
+  Profile* profile = Profile::FromBrowserContext(
+      web_ui->GetWebContents()->GetBrowserContext());
+  WebUIFactoryFunction function = GetWebUIFactoryFunction(web_ui,
                                                           profile, url);
   if (!function)
     return NULL;
-  return (*function)(web_contents, url);
+
+  return (*function)(web_ui, url);  
 }
 
 void ChromeWebUIFactory::GetFaviconForURL(
     Profile* profile,
     FaviconService::GetFaviconRequest* request,
     const GURL& page_url) const {
   // All extensions but the bookmark manager get their favicon from the icons
   // part of the manifest.
   if (page_url.SchemeIs(chrome::kExtensionScheme) &&
       page_url.host() != extension_misc::kBookmarkManagerId) {
@@ skipping 64 matching lines @@
     return OptionsUI::GetFaviconResourceBytes();
 
   if (page_url.host() == chrome::kChromeUISettingsFrameHost)
     return options2::OptionsUI::GetFaviconResourceBytes();
 
   if (page_url.host() == chrome::kChromeUIPluginsHost)
     return PluginsUI::GetFaviconResourceBytes();
 
   return NULL;
 }