WebUI: Get rid of more references to DOMUI in the rest of the directories.

chrome/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 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/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
@@ skipping 649 matching lines @@
 }
 
 bool TabContents::ShouldDisplayURL() {
   // Don't hide the url in view source mode and with interstitials.
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && (entry->IsViewSourceMode() ||
                 entry->page_type() == INTERSTITIAL_PAGE)) {
     return true;
   }
 
-  WebUI* web_ui = GetDOMUIForCurrentState();
+  WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return !web_ui->should_hide_url();
   return true;
 }
 
 SkBitmap TabContents::GetFavIcon() const {
   // Like GetTitle(), we also want to use the favicon for the last committed
   // entry rather than a pending navigation entry.
   NavigationEntry* entry = controller_.GetTransientEntry();
   if (entry)
@@ skipping 15 matching lines @@
     return entry->favicon().is_valid();
 
   return false;
 }
 
 bool TabContents::ShouldDisplayFavIcon() {
   // Always display a throbber during pending loads.
   if (controller_.GetLastCommittedEntry() && controller_.pending_entry())
     return true;
 
-  WebUI* web_ui = GetDOMUIForCurrentState();
+  WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return !web_ui->hide_favicon();
   return true;
 }
 
 string16 TabContents::GetStatusText() const {
   if (!is_loading() || load_state_ == net::LOAD_STATE_IDLE)
     return string16();
 
   switch (load_state_) {
@@ skipping 369 matching lines @@
 
 void TabContents::FocusThroughTabTraversal(bool reverse) {
   if (showing_interstitial_page()) {
     render_manager_.interstitial_page()->FocusThroughTabTraversal(reverse);
     return;
   }
   render_view_host()->SetInitialFocus(reverse);
 }
 
 bool TabContents::FocusLocationBarByDefault() {
-  WebUI* web_ui = GetDOMUIForCurrentState();
+  WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return web_ui->focus_location_bar_by_default();
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && entry->url() == GURL(chrome::kAboutBlankURL))
     return true;
   return false;
 }
 
 void TabContents::SetFocusToLocationBar(bool select_all) {
   if (delegate())
@@ skipping 84 matching lines @@
 }
 
 bool TabContents::ShouldShowBookmarkBar() {
   if (showing_interstitial_page())
     return false;
 
   // Do not show bookmarks bar if bookmarks aren't enabled.
   if (!browser_defaults::bookmarks_enabled)
     return false;
 
-  // See GetDOMUIForCurrentState() comment for more info. This case is very
+  // See GetWebUIForCurrentState() comment for more info. This case is very
   // similar, but for non-first loads, we want to use the committed entry. This
   // is so the bookmarks bar disappears at the same time the page does.
   if (controller_.GetLastCommittedEntry()) {
     // Not the first load, always use the committed Web UI.
     return (render_manager_.web_ui() == NULL) ?
         false : render_manager_.web_ui()->force_bookmark_bar_visible();
   }
 
   // When it's the first load, we know either the pending one or the committed
-  // one will have the Web UI in it (see GetDOMUIForCurrentState), and only one
+  // one will have the Web UI in it (see GetWebUIForCurrentState), and only one
   // of them will be valid, so we can just check both.
   if (render_manager_.pending_web_ui())
     return render_manager_.pending_web_ui()->force_bookmark_bar_visible();
   return (render_manager_.web_ui() == NULL) ?
       false : render_manager_.web_ui()->force_bookmark_bar_visible();
 }
 
 void TabContents::ToolbarSizeChanged(bool is_animating) {
   TabContentsDelegate* d = delegate();
   if (d)
@@ skipping 504 matching lines @@
   // NOTE: It is not safe to change the following code to count upwards or use
   // iterators, as the RemoveInfoBar() call synchronously modifies our delegate
   // list.
   for (size_t i = infobar_count(); i > 0; --i) {
     InfoBarDelegate* delegate = GetInfoBarDelegateAt(i - 1);
     if (delegate->ShouldExpire(details))
       RemoveInfoBar(delegate);
   }
 }
 
-WebUI* TabContents::GetDOMUIForCurrentState() {
+WebUI* TabContents::GetWebUIForCurrentState() {
   // When there is a pending navigation entry, we want to use the pending WebUI
   // that goes along with it to control the basic flags. For example, we want to
   // show the pending URL in the URL bar, so we want the display_url flag to
   // be from the pending entry.
   //
   // The confusion comes because there are multiple possibilities for the
   // initial load in a tab as a side effect of the way the RenderViewHostManager
   // works.
   //
   //  - For the very first tab the load looks "normal". The new tab Web UI is
@@ skipping 31 matching lines @@
     const ViewHostMsg_FrameNavigate_Params& params) {
   if (opener_web_ui_type_ != WebUIFactory::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 (opener_web_ui_type_ ==
         WebUIFactory::GetWebUIType(profile(), GetURL())) {
       WebUI* web_ui = WebUIFactory::CreateWebUIForURL(this, GetURL());
       // web_ui might be NULL if the URL refers to a non-existent extension.
       if (web_ui) {
-        render_manager_.SetDOMUIPostCommit(web_ui);
+        render_manager_.SetWebUIPostCommit(web_ui);
         web_ui->RenderViewCreated(render_view_host());
       }
     }
     opener_web_ui_type_ = WebUIFactory::kNoWebUI;
   }
 
   if (details.is_user_initiated_main_frame_load()) {
     // Clear the status bubble. This is a workaround for a bug where WebKit
     // doesn't let us know that the cursor left an element during a
     // transition (this is also why the mouse cursor remains as a hand after
@@ skipping 1143 matching lines @@
 }
 
 void TabContents::NotifySwappedFromRenderManager() {
   NotifySwapped();
 }
 
 NavigationController& TabContents::GetControllerForRenderManager() {
   return controller();
 }
 
-WebUI* TabContents::CreateDOMUIForRenderManager(const GURL& url) {
+WebUI* TabContents::CreateWebUIForRenderManager(const GURL& url) {
   return WebUIFactory::CreateWebUIForURL(this, url);
 }
 
 NavigationEntry*
 TabContents::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
 bool TabContents::CreateRenderViewForRenderManager(
     RenderViewHost* render_view_host) {
@@ skipping 170 matching lines @@
 }
 
 bool TabContents::MaybeUsePreloadedPage(const GURL& url) {
   PrerenderManager* pm = profile()->GetPrerenderManager();
   if (pm != NULL) {
     if (pm->MaybeUsePreloadedPage(this, url))
       return true;
   }
   return false;
 }