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

chrome/browser/instant/instant_loader.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/instant/instant_loader.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 272 matching lines @@
       loader_(loader),
       registered_render_widget_host_(NULL),
       waiting_for_new_page_(true),
       is_mouse_down_from_activate_(false),
       user_typed_before_load_(false) {
   DCHECK(loader->preview_contents());
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
       content::Source<TabContents>(loader->preview_contents()->tab_contents()));
   registrar_.Add(this, content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       content::Source<NavigationController>(
-          &loader->preview_contents()->controller()));
+          &loader->preview_contents()->tab_contents()->controller()));
 }
 
 void InstantLoader::TabContentsDelegateImpl::PrepareForNewLoad() {
   user_typed_before_load_ = false;
   waiting_for_new_page_ = true;
   add_page_vector_.clear();
   UnregisterForPaintNotifications();
 }
 
 void InstantLoader::TabContentsDelegateImpl::PreviewPainted() {
@@ skipping 236 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void InstantLoader::TabContentsDelegateImpl::OnSetSuggestions(
     int32 page_id,
     const std::vector<std::string>& suggestions,
     InstantCompleteBehavior behavior) {
   TabContentsWrapper* source = loader_->preview_contents();
-  if (!source->controller().GetActiveEntry() ||
-      page_id != source->controller().GetActiveEntry()->page_id())
+  if (!source->tab_contents()->controller().GetActiveEntry() ||
+      page_id !=
+          source->tab_contents()->controller().GetActiveEntry()->page_id()) {
     return;
+  }
 
   if (suggestions.empty())
     loader_->SetCompleteSuggestedText(string16(), behavior);
   else
     loader_->SetCompleteSuggestedText(UTF8ToUTF16(suggestions[0]), behavior);
 }
 
 void InstantLoader::TabContentsDelegateImpl::OnInstantSupportDetermined(
     int32 page_id,
     bool result) {
@@ skipping 98 matching lines @@
     if (!created_preview_contents) {
       if (is_determining_if_page_supports_instant()) {
         // The page hasn't loaded yet. We'll send the script down when it does.
         frame_load_observer_->set_text(user_text_);
         frame_load_observer_->set_verbatim(verbatim);
         preview_tab_contents_delegate_->set_user_typed_before_load();
         return true;
       }
       // TODO: support real cursor position.
       int text_length = static_cast<int>(user_text_.size());
-      RenderViewHost* host = preview_contents_->render_view_host();
+      RenderViewHost* host =
+          preview_contents_->tab_contents()->render_view_host();
       host->Send(new ChromeViewMsg_SearchBoxChange(
           host->routing_id(), user_text_, verbatim, text_length, text_length));
 
       string16 complete_suggested_text_lower = base::i18n::ToLower(
           complete_suggested_text_);
       string16 user_text_lower = base::i18n::ToLower(user_text_);
       if (!verbatim &&
           complete_suggested_text_lower.size() > user_text_lower.size() &&
           !complete_suggested_text_lower.compare(0, user_text_lower.size(),
                                                  user_text_lower)) {
         *suggested_text = last_suggestion_ =
             complete_suggested_text_.substr(user_text_.size());
       }
     } else {
       LoadInstantURL(tab_contents, template_url, transition_type, user_text_,
                      verbatim);
     }
   } else {
     DCHECK(template_url_id_ == 0);
     preview_tab_contents_delegate_->PrepareForNewLoad();
     frame_load_observer_.reset(NULL);
-    preview_contents_->controller().LoadURL(url_, content::Referrer(),
-                                            transition_type, std::string());
+    preview_contents_->tab_contents()->controller().LoadURL(
+        url_, content::Referrer(), transition_type, std::string());
   }
   return true;
 }
 
 void InstantLoader::SetOmniboxBounds(const gfx::Rect& bounds) {
   if (omnibox_bounds_ == bounds)
     return;
 
   // Don't update the page while the mouse is down. http://crbug.com/71952
   if (IsMouseDownFromActivate())
@@ skipping 25 matching lines @@
 TabContentsWrapper* InstantLoader::ReleasePreviewContents(
     InstantCommitType type) {
   if (!preview_contents_.get())
     return NULL;
 
   // FrameLoadObserver is only used for instant results, and instant results are
   // only committed if active (when the FrameLoadObserver isn't installed).
   DCHECK(type == INSTANT_COMMIT_DESTROY || !frame_load_observer_.get());
 
   if (type != INSTANT_COMMIT_DESTROY && is_showing_instant()) {
-    RenderViewHost* host = preview_contents_->render_view_host();
+    RenderViewHost* host =
+        preview_contents_->tab_contents()->render_view_host();
     if (type == INSTANT_COMMIT_FOCUS_LOST) {
       host->Send(new ChromeViewMsg_SearchBoxCancel(host->routing_id()));
     } else {
       host->Send(new ChromeViewMsg_SearchBoxSubmit(
           host->routing_id(), user_text_,
           type == INSTANT_COMMIT_PRESSED_ENTER));
     }
   }
   omnibox_bounds_ = gfx::Rect();
   last_omnibox_bounds_ = gfx::Rect();
@@ skipping 12 matching lines @@
       preview_tab_contents_delegate_->CommitHistory(template_url_id_ != 0);
     }
     if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
 #if defined(OS_MACOSX)
       preview_contents_->tab_contents()->GetRenderWidgetHostView()->
           SetTakesFocusOnlyOnMouseDown(false);
       registrar_.Remove(
           this,
           content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
           content::Source<NavigationController>(
-              &preview_contents_->controller()));
+              &preview_contents_->tab_contents()->controller()));
 #endif
     }
     preview_contents_->tab_contents()->set_delegate(NULL);
     ready_ = false;
   }
   update_bounds_timer_.Stop();
   AddPreviewUsageForHistogram(template_url_id_,
       type == INSTANT_COMMIT_DESTROY ? PREVIEW_DELETED : PREVIEW_COMMITTED);
   return preview_contents_.release();
 }
@@ skipping 16 matching lines @@
   if (preview_contents_.get())
     return;
 
   CreatePreviewContents(tab_contents);
   LoadInstantURL(tab_contents, template_url, content::PAGE_TRANSITION_GENERATED,
                  string16(), true);
 }
 
 bool InstantLoader::IsNavigationPending() const {
   return preview_contents_.get() &&
-      preview_contents_->controller().pending_entry();
+      preview_contents_->tab_contents()->controller().pending_entry();
 }
 
 void InstantLoader::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
 #if defined(OS_MACOSX)
   if (type == content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED) {
     if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
       preview_contents_->tab_contents()->GetRenderWidgetHostView()->
           SetTakesFocusOnlyOnMouseDown(true);
@@ skipping 134 matching lines @@
   SendBoundsToPage(false);
 }
 
 void InstantLoader::SendBoundsToPage(bool force_if_waiting) {
   if (last_omnibox_bounds_ == omnibox_bounds_)
     return;
 
   if (preview_contents_.get() && is_showing_instant() &&
       (force_if_waiting || !is_determining_if_page_supports_instant())) {
     last_omnibox_bounds_ = omnibox_bounds_;
-    RenderViewHost* host = preview_contents_->render_view_host();
+    RenderViewHost* host =
+        preview_contents_->tab_contents()->render_view_host();
     host->Send(new ChromeViewMsg_SearchBoxResize(
         host->routing_id(), GetOmniboxBoundsInTermsOfPreview()));
   }
 }
 
 void InstantLoader::ReplacePreviewContents(TabContentsWrapper* old_tc,
                                            TabContentsWrapper* new_tc) {
   DCHECK(old_tc == preview_contents_);
   // We release here without deleting so that the caller still has reponsibility
   // for deleting the TabContentsWrapper.
   ignore_result(preview_contents_.release());
   preview_contents_.reset(new_tc);
 
   // Make sure the new preview contents acts like the old one.
   SetupPreviewContents(old_tc);
 
   // Cleanup the old preview contents.
   old_tc->constrained_window_tab_helper()->set_delegate(NULL);
   old_tc->core_tab_helper()->set_delegate(NULL);
   old_tc->tab_contents()->set_delegate(NULL);
 
 #if defined(OS_MACOSX)
   registrar_.Remove(
       this,
       content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
-      content::Source<NavigationController>(&old_tc->controller()));
+      content::Source<NavigationController>(
+          &old_tc->tab_contents()->controller()));
 #endif
-  registrar_.Remove(this,
-                 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-                 content::Source<NavigationController>(&old_tc->controller()));
+  registrar_.Remove(
+      this,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::Source<NavigationController>(
+          &old_tc->tab_contents()->controller()));
 
   // We prerendered so we should be ready to show. If we're ready, swap in
   // immediately, otherwise show the preview as normal.
   if (ready_)
     delegate_->SwappedTabContents(this);
   else
     ShowPreview();
 }
 
 void InstantLoader::SetupPreviewContents(TabContentsWrapper* tab_contents) {
   preview_contents_->tab_contents()->set_delegate(
       preview_tab_contents_delegate_.get());
   preview_contents_->blocked_content_tab_helper()->SetAllContentsBlocked(true);
   preview_contents_->constrained_window_tab_helper()->set_delegate(
       preview_tab_contents_delegate_.get());
   preview_contents_->core_tab_helper()->set_delegate(
       preview_tab_contents_delegate_.get());
 
   // Propagate the max page id. That way if we end up merging the two
   // NavigationControllers (which happens if we commit) none of the page ids
   // will overlap.
   int32 max_page_id = tab_contents->tab_contents()->GetMaxPageID();
-  if (max_page_id != -1)
-    preview_contents_->controller().set_max_restored_page_id(max_page_id + 1);
+  if (max_page_id != -1) {
+    preview_contents_->tab_contents()->controller().set_max_restored_page_id(
+        max_page_id + 1);
+  }
 
 #if defined(OS_MACOSX)
   // If |preview_contents_| does not currently have a RWHV, we will call
   // SetTakesFocusOnlyOnMouseDown() as a result of the
   // RENDER_VIEW_HOST_CHANGED notification.
   if (preview_contents_->tab_contents()->GetRenderWidgetHostView()) {
     preview_contents_->tab_contents()->GetRenderWidgetHostView()->
         SetTakesFocusOnlyOnMouseDown(true);
   }
   registrar_.Add(
       this,
       content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
-      content::Source<NavigationController>(&preview_contents_->controller()));
+      content::Source<NavigationController>(
+          &preview_contents_->tab_contents()->controller()));
 #endif
 
   registrar_.Add(
       this,
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<NavigationController>(&preview_contents_->controller()));
+      content::Source<NavigationController>(
+          &preview_contents_->tab_contents()->controller()));
 
   gfx::Rect tab_bounds;
-  tab_contents->view()->GetContainerBounds(&tab_bounds);
-  preview_contents_->view()->SizeContents(tab_bounds.size());
+  tab_contents->tab_contents()->view()->GetContainerBounds(&tab_bounds);
+  preview_contents_->tab_contents()->view()->SizeContents(tab_bounds.size());
 }
 
 void InstantLoader::CreatePreviewContents(TabContentsWrapper* tab_contents) {
   TabContents* new_contents =
       new TabContents(
           tab_contents->profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   preview_contents_.reset(new TabContentsWrapper(new_contents));
   AddPreviewUsageForHistogram(template_url_id_, PREVIEW_CREATED);
   preview_tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   SetupPreviewContents(tab_contents);
@@ skipping 14 matching lines @@
   // This uses an empty string for the replacement text as the url doesn't
   // really have the search params, but we need to use the replace
   // functionality so that embeded tags (like {google:baseURL}) are escaped
   // correctly.
   // TODO(sky): having to use a replaceable url is a bit of a hack here.
   GURL instant_url(template_url->instant_url()->ReplaceSearchTermsUsingProfile(
       tab_contents->profile(), *template_url, string16(), -1, string16()));
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kInstantURL))
     instant_url = GURL(cl->GetSwitchValueASCII(switches::kInstantURL));
-  preview_contents_->controller().LoadURL(instant_url, content::Referrer(),
-                                          transition_type, std::string());
-  RenderViewHost* host = preview_contents_->render_view_host();
+  preview_contents_->tab_contents()->controller().LoadURL(
+      instant_url, content::Referrer(), transition_type, std::string());
+  RenderViewHost* host = preview_contents_->tab_contents()->render_view_host();
   preview_contents_->tab_contents()->HideContents();
 
   // If user_text is empty, this must be a preload of the search homepage. In
   // that case, send down a SearchBoxResize message, which will switch the page
   // to "search results" UI. This avoids flicker when the page is shown with
   // results. In addition, we don't want the page accidentally causing the
   // preloaded page to be displayed yet (by calling setSuggestions), so don't
   // send a SearchBoxChange message.
   if (user_text.empty()) {
     host->Send(new ChromeViewMsg_SearchBoxResize(
         host->routing_id(), GetOmniboxBoundsInTermsOfPreview()));
   } else {
     host->Send(new ChromeViewMsg_SearchBoxChange(
         host->routing_id(), user_text, verbatim, 0, 0));
   }
 
   frame_load_observer_.reset(new FrameLoadObserver(
       this, preview_contents()->tab_contents(), user_text, verbatim));
 }