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

content/browser/tab_contents/tab_contents.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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 103 matching lines @@
 using content::DownloadManager;
 using content::GlobalRequestID;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
 using content::OpenURLParams;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 using content::WebContentsObserver;
+using content::WebUIController;
 
 namespace {
 
 // Amount of time we wait between when a key event is received and the renderer
 // is queried for its state and pushed to the NavigationEntry.
 const int kQueryStateDelay = 5000;
 
 const int kSyncWaitDelay = 40;
 
 static const char kDotGoogleDotCom[] = ".google.com";
@@ skipping 290 matching lines @@
 }
 
 RenderWidgetHostView* TabContents::GetRenderWidgetHostView() const {
   return render_manager_.GetRenderWidgetHostView();
 }
 
 TabContentsView* TabContents::GetView() const {
   return view_.get();
 }
 
+WebUI* TabContents::CreateWebUI(const GURL& url) {
+  WebUI* web_ui = new WebUI(this);
+  WebUIController* controller =
+      content::GetContentClient()->browser()->GetWebUIFactory()->
+          CreateWebUIForURL(web_ui, url);
+  if (controller) {
+    web_ui->SetController(controller);
+    return web_ui;
+  }
+
+  delete web_ui;
+  return NULL;
+}
+
 WebUI* TabContents::GetWebUI() const {
   return render_manager_.web_ui() ? render_manager_.web_ui()
       : render_manager_.pending_web_ui();
 }
 
 WebUI* TabContents::GetCommittedWebUI() const {
   return render_manager_.web_ui();
 }
 
 const string16& TabContents::GetTitle() const {
   // Transient entries take precedence. They are used for interstitial pages
   // that are shown on top of existing pages.
   NavigationEntry* entry = controller_.GetTransientEntry();
   std::string accept_languages =
       content::GetContentClient()->browser()->GetAcceptLangs(
           GetBrowserContext());
   if (entry) {
     return entry->GetTitleForDisplay(accept_languages);
   }
   WebUI* our_web_ui = render_manager_.pending_web_ui() ?
       render_manager_.pending_web_ui() : render_manager_.web_ui();
   if (our_web_ui) {
     // Don't override the title in view source mode.
     entry = controller_.GetActiveEntry();
     if (!(entry && entry->IsViewSourceMode())) {
       // Give the Web UI the chance to override our title.
-      const string16& title = our_web_ui->overridden_title();
+      const string16& title = our_web_ui->GetOverriddenTitle();
       if (!title.empty())
         return title;
     }
   }
 
   // We use the title for the last committed entry rather than a pending
   // navigation entry. For example, when the user types in a URL, we want to
   // keep the old page's title until the new load has committed and we get a new
   // title.
   entry = controller_.GetLastCommittedEntry();
@@ skipping 643 matching lines @@
 }
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return GetRenderViewHost() ?
       GetRenderViewHost()->GotResponseToLockMouseRequest(allowed) : false;
 }
 
 bool TabContents::FocusLocationBarByDefault() {
   WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
-    return web_ui->focus_location_bar_by_default();
+    return web_ui->ShouldFocusLocationBarByDefault();
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && entry->GetURL() == GURL(chrome::kAboutBlankURL))
     return true;
   return false;
 }
 
 void TabContents::SetFocusToLocationBar(bool select_all) {
   if (delegate_)
     delegate_->SetFocusToLocationBar(select_all);
 }
@@ skipping 323 matching lines @@
 }
 
 void TabContents::DidNavigateMainFramePostCommit(
     const content::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   if (opener_web_ui_type_ != WebUI::kNoWebUI) {
     // If this is a window.open navigation, use the same WebUI as the renderer
     // that opened the window, as long as both renderers have the same
     // privileges.
     if (delegate_ && opener_web_ui_type_ == GetWebUITypeForCurrentState()) {
-      WebUI* web_ui = content::GetContentClient()->browser()->
-          GetWebUIFactory()->CreateWebUIForURL(this, GetURL());
+      WebUI* web_ui = CreateWebUI(GetURL());
       // web_ui might be NULL if the URL refers to a non-existent extension.
       if (web_ui) {
         render_manager_.SetWebUIPostCommit(web_ui);
         web_ui->RenderViewCreated(GetRenderViewHost());
       }
     }
     opener_web_ui_type_ = WebUI::kNoWebUI;
   }
 
   if (details.is_navigation_to_different_page()) {
@@ skipping 457 matching lines @@
   if (render_manager_.web_ui()) {
     // When we're a Web UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
     //
     // Note also that we hide the referrer for Web UI pages. We don't really
     // want web sites to see a referrer of "chrome://blah" (and some
     // chrome: URLs might have search terms or other stuff we don't want to
     // send to the site), so we send no referrer.
     OpenURLParams params(url, content::Referrer(), disposition,
-        render_manager_.web_ui()->link_transition_type(),
+        render_manager_.web_ui()->GetLinkTransitionType(),
         false /* is_renderer_initiated */);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
-    transition_type = render_manager_.web_ui()->link_transition_type();
+    transition_type = render_manager_.web_ui()->GetLinkTransitionType();
   } else {
     OpenURLParams params(url, referrer, disposition,
         content::PAGE_TRANSITION_LINK, true /* is_renderer_initiated */);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
   }
   if (new_contents) {
     // Notify observers.
     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                       DidOpenRequestedURL(new_contents,
@@ skipping 209 matching lines @@
 
 void TabContents::NotifySwappedFromRenderManager() {
   NotifySwapped();
 }
 
 NavigationControllerImpl& TabContents::GetControllerForRenderManager() {
   return GetControllerImpl();
 }
 
 WebUI* TabContents::CreateWebUIForRenderManager(const GURL& url) {
-  return content::GetContentClient()->browser()->GetWebUIFactory()->
-      CreateWebUIForURL(this, url);
+  return CreateWebUI(url);
 }
 
 NavigationEntry*
     TabContents::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
 bool TabContents::CreateRenderViewForRenderManager(
     RenderViewHost* render_view_host) {
   // Can be NULL during tests.
@@ skipping 49 matching lines @@
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }