Clean up TCW, make it solely a hub for 1:1 observer/helper objects.

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 130 matching lines @@
 #include "content/browser/download/download_item.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/download/save_package.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
+#include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/user_metrics.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/intents_host.h"
 #include "content/public/common/content_restriction.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "grit/chromium_strings.h"
@@ skipping 1314 matching lines @@
 bool Browser::IsClosingPermitted() {
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   bool can_close = !watcher || watcher->CanCloseBrowser(this);
   if (!can_close && is_attempting_to_close_browser_)
     CancelWindowClose();
   return can_close;
 }
 
 bool Browser::CanGoBack() const {
-  return GetSelectedTabContentsWrapper()->controller().CanGoBack();
+  return GetSelectedTabContentsWrapper()->
+      tab_contents()->controller().CanGoBack();
 }
 
 void Browser::GoBack(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Back"));
 
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   if (CanGoBack()) {
     TabContents* new_tab = GetOrCloneTabForDisposition(disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->tab_contents()->showing_interstitial_page() &&
         (new_tab != current_tab->tab_contents()))
       return;
     new_tab->controller().GoBack();
   }
 }
 
 bool Browser::CanGoForward() const {
-  return GetSelectedTabContentsWrapper()->controller().CanGoForward();
+  return GetSelectedTabContentsWrapper()->
+      tab_contents()->controller().CanGoForward();
 }
 
 void Browser::GoForward(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward())
     GetOrCloneTabForDisposition(disposition)->controller().GoForward();
 }
 
 void Browser::Reload(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Reload"));
@@ skipping 114 matching lines @@
 void Browser::CloseWindow() {
   UserMetrics::RecordAction(UserMetricsAction("CloseWindow"));
   window_->Close();
 }
 
 void Browser::NewTab() {
   UserMetrics::RecordAction(UserMetricsAction("NewTab"));
 
   if (is_type_tabbed()) {
     AddBlankTab(true);
-    GetSelectedTabContentsWrapper()->view()->RestoreFocus();
+    GetSelectedTabContentsWrapper()->tab_contents()->view()->RestoreFocus();
   } else {
     Browser* b = GetOrCreateTabbedBrowser(profile_);
     b->AddBlankTab(true);
     b->window()->Show();
     // The call to AddBlankTab above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
-    b->GetSelectedTabContentsWrapper()->view()->RestoreFocus();
+    b->GetSelectedTabContentsWrapper()->tab_contents()->view()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
   UserMetrics::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   if (CanCloseTab())
     tab_handler_->GetTabStripModel()->CloseSelectedTabs();
 }
 
 void Browser::SelectNextTab() {
@@ skipping 261 matching lines @@
 
 void Browser::FindPrevious() {
   UserMetrics::RecordAction(UserMetricsAction("FindPrevious"));
   FindInPage(true, false);
 }
 
 void Browser::Zoom(content::PageZoom zoom) {
   if (is_devtools())
     return;
 
-  RenderViewHost* host = GetSelectedTabContentsWrapper()->render_view_host();
+  RenderViewHost* host =
+      GetSelectedTabContentsWrapper()->tab_contents()->render_view_host();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
     UserMetrics::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
   double current_zoom_level = GetSelectedTabContents()->GetZoomLevel();
   double default_zoom_level =
       profile_->GetPrefs()->GetDouble(prefs::kDefaultZoomLevel);
 
@@ skipping 93 matching lines @@
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   UserMetrics::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   DCHECK(current_tab &&
       web_app::IsValidUrl(current_tab->tab_contents()->GetURL())) <<
           "Menu item should be disabled.";
 
-  NavigationEntry* entry = current_tab->controller().GetLastCommittedEntry();
+  NavigationEntry* entry =
+      current_tab->tab_contents()->controller().GetLastCommittedEntry();
   if (!entry)
     return;
 
   // RVH's GetApplicationInfo should not be called before it returns.
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
   current_tab->extension_tab_helper()->GetApplicationInfo(entry->page_id());
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void Browser::ToggleDevToolsWindow(DevToolsToggleAction action) {
   if (action == DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE)
     UserMetrics::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
     UserMetrics::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 
   DevToolsWindow::ToggleDevToolsWindow(
-      GetSelectedTabContentsWrapper()->render_view_host(), action);
+      GetSelectedTabContentsWrapper()->tab_contents()->render_view_host(),
+      action);
 }
 
 void Browser::OpenTaskManager(bool highlight_background_resources) {
   UserMetrics::RecordAction(UserMetricsAction("TaskManager"));
   if (highlight_background_resources)
     window_->ShowBackgroundPages();
   else
     window_->ShowTaskManager();
 }
 
@@ skipping 988 matching lines @@
 TabContentsWrapper* Browser::CreateTabContentsForURL(
     const GURL& url, const content::Referrer& referrer, Profile* profile,
     content::PageTransition transition, bool defer_load,
     SiteInstance* instance) const {
   TabContentsWrapper* contents = TabContentsFactory(profile, instance,
       MSG_ROUTING_NONE,
       GetSelectedTabContents(), NULL);
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
-    contents->controller().LoadURL(url, referrer, transition, std::string());
+    contents->tab_contents()->controller().LoadURL(
+        url, referrer, transition, std::string());
   }
 
   return contents;
 }
 
 bool Browser::CanDuplicateContentsAt(int index) {
   NavigationController& nc = GetTabContentsAt(index)->controller();
   return nc.tab_contents() && nc.GetLastCommittedEntry();
 }
 
@@ skipping 65 matching lines @@
 
   // We don't create historical tabs for print preview tabs.
   if (contents->tab_contents()->GetURL() == GURL(chrome::kChromeUIPrintURL))
     return;
 
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile());
 
   // We only create historical tab entries for tabbed browser windows.
   if (service && CanSupportWindowFeature(FEATURE_TABSTRIP)) {
-    service->CreateHistoricalTab(&contents->controller(),
+    service->CreateHistoricalTab(&contents->tab_contents()->controller(),
         tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents));
   }
 }
 
 bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
   return Browser::RunUnloadEventsHelper(contents->tab_contents());
 }
 
 bool Browser::CanReloadContents(TabContents* source) const {
   return !is_devtools();
@@ skipping 67 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                  content::Source<TabContents>(contents->tab_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
   fullscreen_controller_->OnTabClosing(contents->tab_contents());
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSING,
-      content::Source<NavigationController>(&contents->controller()),
+      content::Source<NavigationController>(
+          &contents->tab_contents()->controller()),
       content::NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
@@ skipping 77 matching lines @@
 }
 
 void Browser::TabReplacedAt(TabStripModel* tab_strip_model,
                             TabContentsWrapper* old_contents,
                             TabContentsWrapper* new_contents,
                             int index) {
   TabDetachedAtImpl(old_contents, index, DETACH_TYPE_REPLACE);
   TabInsertedAt(new_contents, index,
                 (index == tab_handler_->GetTabStripModel()->active_index()));
 
-  int entry_count = new_contents->controller().entry_count();
+  int entry_count = new_contents->tab_contents()->controller().entry_count();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
-    new_contents->controller().NotifyEntryChanged(
-        new_contents->controller().GetEntryAtIndex(entry_count - 1),
+    new_contents->tab_contents()->controller().NotifyEntryChanged(
+        new_contents->tab_contents()->controller().GetEntryAtIndex(
+            entry_count - 1),
         entry_count - 1);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile());
   if (session_service) {
     // The new_contents may end up with a different navigation stack. Force
     // the session service to update itself.
     session_service->TabRestored(
         new_contents, tab_handler_->GetTabStripModel()->IsTabPinned(index));
@@ skipping 593 matching lines @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
 
 void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
                                       int32 page_id) {
   if (GetSelectedTabContentsWrapper() != source)
     return;
 
-  NavigationEntry* entry = source->controller().GetLastCommittedEntry();
+  NavigationEntry* entry =
+      source->tab_contents()->controller().GetLastCommittedEntry();
   if (!entry || (entry->page_id() != page_id))
     return;
 
   switch (pending_web_app_action_) {
     case CREATE_SHORTCUT: {
       window()->ShowCreateWebAppShortcutsDialog(source);
       break;
     }
     case UPDATE_SHORTCUT: {
       web_app::UpdateShortcutForTabContents(source);
@@ skipping 1157 matching lines @@
             INSTANT_COMMIT_PRESSED_ENTER)),
         content::NotificationService::NoDetails());
     return true;
   }
   if (disposition == NEW_FOREGROUND_TAB) {
     TabContentsWrapper* preview_contents = instant()->ReleasePreviewContents(
         INSTANT_COMMIT_PRESSED_ENTER);
     // HideInstant is invoked after release so that InstantController is not
     // active when HideInstant asks it for its state.
     HideInstant();
-    preview_contents->controller().PruneAllButActive();
+    preview_contents->tab_contents()->controller().PruneAllButActive();
     tab_handler_->GetTabStripModel()->AddTabContents(
         preview_contents,
         -1,
         instant()->last_transition_type(),
         TabStripModel::ADD_ACTIVE);
     instant()->CompleteRelease(preview_contents);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_COMMITTED,
         content::Source<TabContentsWrapper>(preview_contents),
         content::NotificationService::NoDetails());
@@ skipping 10 matching lines @@
   if (is_type_tabbed() && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(profile_, this));
     instant_unload_handler_.reset(new InstantUnloadHandler(this));
   }
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents) {
   DCHECK(contents);
 
-  NavigationEntry* active_entry = contents->controller().GetActiveEntry();
+  NavigationEntry* active_entry =
+      contents->tab_contents()->controller().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(contents, active_entry->url(), active_entry->content_state());
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents,
                          const GURL& url,
                          const std::string& content_state) {
   UserMetrics::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   TabContentsWrapper* view_source_contents = contents->Clone();
-  view_source_contents->controller().PruneAllButActive();
+  view_source_contents->tab_contents()->controller().PruneAllButActive();
   NavigationEntry* active_entry =
-      view_source_contents->controller().GetActiveEntry();
+      view_source_contents->tab_contents()->controller().GetActiveEntry();
   if (!active_entry)
     return;
 
   GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
       url.spec());
   active_entry->set_virtual_url(view_source_url);
 
   // Do not restore scroller position.
   active_entry->set_content_state(
       webkit_glue::RemoveScrollOffsetFromHistoryState(content_state));
@@ skipping 87 matching lines @@
 void Browser::ShowSyncSetup() {
   ProfileSyncService* service =
       profile()->GetOriginalProfile()->GetProfileSyncService();
   if (service->HasSyncSetupCompleted())
     ShowOptionsTab(chrome::kPersonalOptionsSubPage);
   else
     service->ShowLoginDialog();
 }
 
 void Browser::ToggleSpeechInput() {
-  GetSelectedTabContentsWrapper()->render_view_host()->ToggleSpeechInput();
+  GetSelectedTabContentsWrapper()->tab_contents()->render_view_host()->
+      ToggleSpeechInput();
 }
 
 void Browser::OnWindowDidShow() {
   if (window_has_shown_)
     return;
   window_has_shown_ = true;
 
   // Nothing to do for non-tabbed windows.
   if (!is_type_tabbed())
     return;
@@ skipping 24 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }