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

chrome/browser/external_tab_container_win.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/external_tab_container_win.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 24 matching lines @@
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/provisional_load_details.h"
+#include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/intents_host.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/page_zoom.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
@@ skipping 105 matching lines @@
     NOTREACHED();
     return false;
   }
 
   // TODO(jcampan): limit focus traversal to contents.
 
   prop_.reset(new ViewProp(GetNativeView(), kWindowObjectKey, this));
 
   if (existing_contents) {
     tab_contents_.reset(existing_contents);
-    tab_contents_->controller().set_browser_context(profile);
+    tab_contents_->tab_contents()->controller().set_browser_context(profile);
   } else {
     TabContents* new_contents = new TabContents(profile, NULL, MSG_ROUTING_NONE,
                                                 NULL, NULL);
     tab_contents_.reset(new TabContentsWrapper(new_contents));
   }
 
   if (!infobars_enabled)
     tab_contents_->infobar_tab_helper()->set_infobars_enabled(false);
 
   tab_contents_->tab_contents()->set_delegate(this);
 
   tab_contents_->tab_contents()->
       GetMutableRendererPrefs()->browser_handles_top_level_requests =
           handle_top_level_requests;
 
   if (!existing_contents) {
-    tab_contents_->render_view_host()->AllowBindings(
+    tab_contents_->tab_contents()->render_view_host()->AllowBindings(
         content::BINDINGS_POLICY_EXTERNAL_HOST);
   }
 
-  NavigationController* controller = &tab_contents_->controller();
+  NavigationController* controller =
+      &tab_contents_->tab_contents()->controller();
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::Source<NavigationController>(controller));
   registrar_.Add(this, content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
                  content::Source<NavigationController>(controller));
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::Source<NavigationController>(controller));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
                  content::Source<TabContents>(tab_contents_->tab_contents()));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_DELETED,
                  content::NotificationService::AllSources());
@@ skipping 27 matching lines @@
 
   LoadAccelerators();
   SetupExternalTabView();
   tab_contents_->blocked_content_tab_helper()->set_delegate(this);
   return true;
 }
 
 void ExternalTabContainer::Uninitialize() {
   registrar_.RemoveAll();
   if (tab_contents_.get()) {
-    UnregisterRenderViewHost(tab_contents_->render_view_host());
+    UnregisterRenderViewHost(tab_contents_->tab_contents()->render_view_host());
 
     if (GetWidget()->GetRootView())
       GetWidget()->GetRootView()->RemoveAllChildViews(true);
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTERNAL_TAB_CLOSED,
-        content::Source<NavigationController>(&tab_contents_->controller()),
+        content::Source<NavigationController>(
+            &tab_contents_->tab_contents()->controller()),
         content::Details<ExternalTabContainer>(this));
 
     tab_contents_.reset(NULL);
   }
 
   if (focus_manager_) {
     focus_manager_->UnregisterAccelerators(this);
     focus_manager_ = NULL;
   }
 
@@ skipping 553 matching lines @@
             tab_handle_, commit->http_status_code, commit->entry->url()));
 
         ignore_next_load_notification_ = true;
       } else {
         NavigationInfo navigation_info;
         // When the previous entry index is invalid, it will be -1, which
         // will still make the computation come out right (navigating to the
         // 0th entry will be +1).
         if (InitNavigationInfo(&navigation_info, commit->type,
                 commit->previous_entry_index -
-                tab_contents_->controller().last_committed_entry_index()))
+                tab_contents_->tab_contents()->
+                    controller().last_committed_entry_index()))
           automation_->Send(new AutomationMsg_DidNavigate(tab_handle_,
                                                           navigation_info));
       }
       break;
     }
     case content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR: {
       const ProvisionalLoadDetails* load_details =
           content::Details<ProvisionalLoadDetails>(details).ptr();
       automation_->Send(new AutomationMsg_NavigationFailed(
           tab_handle_, load_details->error_code(), load_details->url()));
@@ skipping 100 matching lines @@
   msg.wParam = wparam;
   msg.lParam = lparam;
   automation_->Send(new AutomationMsg_HandleAccelerator(tab_handle_, msg));
   return true;
 }
 
 bool ExternalTabContainer::InitNavigationInfo(NavigationInfo* nav_info,
                                               content::NavigationType nav_type,
                                               int relative_offset) {
   DCHECK(nav_info);
-  NavigationEntry* entry = tab_contents_->controller().GetActiveEntry();
+  NavigationEntry* entry =
+      tab_contents_->tab_contents()->controller().GetActiveEntry();
   // If this is very early in the game then we may not have an entry.
   if (!entry)
     return false;
 
   nav_info->navigation_type = nav_type;
   nav_info->relative_offset = relative_offset;
   nav_info->navigation_index =
-      tab_contents_->controller().GetCurrentEntryIndex();
+      tab_contents_->tab_contents()->controller().GetCurrentEntryIndex();
   nav_info->url = entry->url();
   nav_info->referrer = entry->referrer().url;
   nav_info->title =  UTF16ToWideHack(entry->title());
   if (nav_info->title.empty())
     nav_info->title = UTF8ToWide(nav_info->url.spec());
 
   nav_info->security_style = entry->ssl().security_style();
   nav_info->displayed_insecure_content =
       entry->ssl().displayed_insecure_content();
   nav_info->ran_insecure_content = entry->ssl().ran_insecure_content();
@@ skipping 27 matching lines @@
 bool ExternalTabContainer::DrawInfoBarArrows(int* x) const {
   return false;
 }
 
 bool ExternalTabContainer::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   std::map<ui::Accelerator, int>::const_iterator iter =
       accelerator_table_.find(accelerator);
   DCHECK(iter != accelerator_table_.end());
 
-  if (!tab_contents_.get() || !tab_contents_->render_view_host()) {
+  if (!tab_contents_.get() ||
+      !tab_contents_->tab_contents()->render_view_host()) {
     NOTREACHED();
     return false;
   }
 
-  RenderViewHost* host = tab_contents_->render_view_host();
+  RenderViewHost* host = tab_contents_->tab_contents()->render_view_host();
   int command_id = iter->second;
   switch (command_id) {
     case IDC_ZOOM_PLUS:
       host->Zoom(content::PAGE_ZOOM_IN);
       break;
     case IDC_ZOOM_NORMAL:
       host->Zoom(content::PAGE_ZOOM_RESET);
       break;
     case IDC_ZOOM_MINUS:
       host->Zoom(content::PAGE_ZOOM_OUT);
       break;
     case IDC_DEV_TOOLS:
       DevToolsWindow::ToggleDevToolsWindow(
-          tab_contents_->render_view_host(), DEVTOOLS_TOGGLE_ACTION_NONE);
+          tab_contents_->tab_contents()->render_view_host(),
+          DEVTOOLS_TOGGLE_ACTION_NONE);
       break;
     case IDC_DEV_TOOLS_CONSOLE:
       DevToolsWindow::ToggleDevToolsWindow(
-          tab_contents_->render_view_host(),
+          tab_contents_->tab_contents()->render_view_host(),
           DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE);
       break;
     case IDC_DEV_TOOLS_INSPECT:
       DevToolsWindow::ToggleDevToolsWindow(
-          tab_contents_->render_view_host(),
+          tab_contents_->tab_contents()->render_view_host(),
           DEVTOOLS_TOGGLE_ACTION_INSPECT);
       break;
     default:
       NOTREACHED() << "Unsupported accelerator: " << command_id;
       return false;
   }
   return true;
 }
 
 void ExternalTabContainer::Navigate(const GURL& url, const GURL& referrer) {
   if (!tab_contents_.get()) {
     NOTREACHED();
     return;
   }
 
   TRACE_EVENT_BEGIN_ETW("ExternalTabContainer::Navigate", 0, url.spec());
 
-  tab_contents_->controller().LoadURL(
+  tab_contents_->tab_contents()->controller().LoadURL(
       url, content::Referrer(referrer, WebKit::WebReferrerPolicyDefault),
       content::PAGE_TRANSITION_START_PAGE, std::string());
 }
 
 bool ExternalTabContainer::OnGoToEntryOffset(int offset) {
   if (load_requests_via_automation_) {
     automation_->Send(new AutomationMsg_RequestGoToHistoryEntryOffset(
         tab_handle_, offset));
     return false;
   }
@@ skipping 32 matching lines @@
     accelerator_table_[accelerator] = accelerators[i].cmd;
 
     // Also register with the focus manager.
     if (focus_manager_)
       focus_manager_->RegisterAccelerator(accelerator, this);
   }
 }
 
 void ExternalTabContainer::OnReinitialize() {
   if (load_requests_via_automation_) {
-    RenderViewHost* rvh = tab_contents_->render_view_host();
+    RenderViewHost* rvh = tab_contents_->tab_contents()->render_view_host();
     if (rvh) {
       AutomationResourceMessageFilter::ResumePendingRenderView(
           rvh->process()->GetID(), rvh->routing_id(),
           tab_handle_, automation_resource_message_filter_);
     }
   }
 
   NavigationStateChanged(tab_contents(), 0);
   ServicePendingOpenURLRequests();
 }
@@ skipping 64 matching lines @@
   if (params.disposition == CURRENT_TAB) {
     DCHECK(route_all_top_level_navigations_);
     forward_params.disposition = NEW_FOREGROUND_TAB;
   }
   TabContents* new_contents =
       ExternalTabContainer::OpenURLFromTab(source, forward_params);
   // support only one navigation for a dummy tab before it is killed.
   ::DestroyWindow(GetNativeView());
   return new_contents;
 }