Remove TabContents from OmniboxEditController and friends.

chrome/browser/ui/omnibox/omnibox_edit_model.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 "chrome/browser/ui/omnibox/omnibox_edit_model.h"
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 530 matching lines @@
   // We only care about cases where there is a selection (i.e. the popup is
   // open).
   if (popup_->IsOpen()) {
     // TODO(sreeram): Handle is_temporary_text_set_by_instant_ correctly.
     AutocompleteLog log(
         autocomplete_controller_->input().text(),
         just_deleted_text_,
         autocomplete_controller_->input().type(),
         popup_->selected_line(),
         -1,  // don't yet know tab ID; set later if appropriate
-        ClassifyPage(controller_->GetTabContents()->
-                     web_contents()->GetURL()),
+        ClassifyPage(controller_->GetWebContents()->GetURL()),
         base::TimeTicks::Now() - time_user_first_modified_omnibox_,
         string16::npos,  // inline autocomplete length; possibly set later
         result());
     DCHECK(user_input_in_progress_ ||
            match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST)
         << "We didn't get here through the expected series of calls. "
         << "time_user_first_modified_omnibox_ is not set correctly and other "
         << "things may be wrong. Match provider: " << match.provider->GetName();
     if (index != OmniboxPopupModel::kNoMatch)
       log.selected_index = index;
     else if (!has_temporary_text_)
       log.inline_autocompleted_length = inline_autocomplete_text_.length();
     if (disposition == CURRENT_TAB) {
       // If we know the destination is being opened in the current tab,
       // we can easily get the tab ID.  (If it's being opened in a new
       // tab, we don't know the tab ID yet.)
       log.tab_id = SessionTabHelper::FromWebContents(
-          controller_->GetTabContents()->web_contents())->session_id().id();
+          controller_->GetWebContents())->session_id().id();
     }
     autocomplete_controller_->AddProvidersInfo(&log.providers_info);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
         content::Source<Profile>(profile_),
         content::Details<AutocompleteLog>(&log));
     HISTOGRAM_ENUMERATION("Omnibox.EventCount", 1, 2);
   }
 
   TemplateURL* template_url = match.GetTemplateURL(profile_, false);
   if (template_url) {
     if (match.transition == content::PAGE_TRANSITION_KEYWORD) {
       // The user is using a non-substituting keyword or is explicitly in
       // keyword mode.
 
       // Special case for extension keywords. Don't increment usage count for
       // these.
       if (template_url->IsExtensionKeyword()) {
         AutocompleteMatch current_match;
         GetInfoForCurrentText(&current_match, NULL);
 
         const AutocompleteMatch& match =
             (index == OmniboxPopupModel::kNoMatch) ?
                 current_match : result().match_at(index);
 
         // Strip the keyword + leading space off the input.
         size_t prefix_length = match.keyword.length() + 1;
         extensions::ExtensionOmniboxEventRouter::OnInputEntered(
-            controller_->GetTabContents(),
+            controller_->GetWebContents(),
             template_url->GetExtensionId(),
             UTF16ToUTF8(match.fill_into_edit.substr(prefix_length)));
         view_->RevertAll();
         return;
       }
 
       content::RecordAction(UserMetricsAction("AcceptedKeyword"));
       TemplateURLServiceFactory::GetForProfile(profile_)->IncrementUsageCount(
           template_url);
     } else {
@@ skipping 104 matching lines @@
 }
 
 void OmniboxEditModel::OnSetFocus(bool control_down) {
   has_focus_ = true;
   control_key_state_ = control_down ? DOWN_WITHOUT_CHANGE : UP;
 
   InstantController* instant = controller_->GetInstant();
   if (instant)
     instant->OnAutocompleteGotFocus();
 
-  TabContents* tab_contents = controller_->GetTabContents();
-  if (tab_contents) {
+  content::WebContents* web_contents = controller_->GetWebContents();
+  if (web_contents) {
     // TODO(jered): We may want to merge this into Start() and just call that
     // here rather than having a special entry point for zero-suggest.  Note
     // that we avoid PermanentURL() here because it's not guaranteed to give us
     // the actual underlying current URL, e.g. if we're on the NTP and the
     // |permanent_text_| is empty.
-    autocomplete_controller_->StartZeroSuggest(
-        tab_contents->web_contents()->GetURL(), user_text_);
+    autocomplete_controller_->StartZeroSuggest(web_contents->GetURL(),
+                                               user_text_);
   }
 
   NotifySearchTabHelper();
 }
 
 void OmniboxEditModel::OnWillKillFocus(gfx::NativeView view_gaining_focus) {
   SetInstantSuggestion(InstantSuggestion());
 
   if (InstantController* instant = controller_->GetInstant())
     instant->OnAutocompleteLostFocus(view_gaining_focus);
@@ skipping 14 matching lines @@
     AutocompleteMatch match;
     InfoForCurrentSelection(&match, NULL);
     if (match.destination_url != original_url_) {
       RevertTemporaryText(true);
       return true;
     }
   }
 
   // We do not clear the pending entry from the omnibox when a load is first
   // stopped.  If the user presses Escape while stopped, we clear it.
-  content::WebContents* contents =
-      controller_->GetTabContents()->web_contents();
+  content::WebContents* contents = controller_->GetWebContents();
   if (!contents->IsLoading()) {
     contents->GetController().DiscardNonCommittedEntries();
     view_->Update(NULL);
   }
 
   // Let Instant decide whether to hide itself.
   if (InstantController* instant = controller_->GetInstant())
     instant->OnEscapeKeyPressed();
 
   // If the user wasn't editing, but merely had focus in the edit, allow <esc>
@@ skipping 398 matching lines @@
   string16 keyword;
   TrimWhitespace(new_text.substr(0, space_position), TRIM_LEADING, &keyword);
   // TODO(sreeram): Once the Instant extended API supports keywords properly,
   // keyword_provider() should never be NULL. Remove that clause.
   return !keyword.empty() && autocomplete_controller_->keyword_provider() &&
       !autocomplete_controller_->keyword_provider()->
           GetKeywordForText(keyword).empty();
 }
 
 void OmniboxEditModel::NotifySearchTabHelper() {
-  if (controller_->GetTabContents()) {
+  if (controller_->GetWebContents()) {
     chrome::search::SearchTabHelper::FromWebContents(
-        controller_->GetTabContents()->web_contents())->
+        controller_->GetWebContents())->
             OmniboxEditModelChanged(user_input_in_progress_, !in_revert_);
   }
 }
 
 bool OmniboxEditModel::DoInstant(const AutocompleteMatch& match) {
   if (in_revert_)
     return false;
 
   InstantController* instant = controller_->GetInstant();
 
@@ skipping 27 matching lines @@
   return false;
 }
 
 void OmniboxEditModel::DoPrerender(const AutocompleteMatch& match) {
   // Do not prerender if the destination URL is the same as the current URL.
   if (match.destination_url == PermanentURL())
     return;
   // It's possible the tab strip does not have an active tab contents, for
   // instance if the tab has been closed or on return from a sleep state
   // (http://crbug.com/105689)
-  TabContents* tab = controller_->GetTabContents();
+  content::WebContents* tab = controller_->GetWebContents();
   if (!tab)
     return;
   gfx::Rect container_bounds;
-  tab->web_contents()->GetView()->GetContainerBounds(&container_bounds);
+  tab->GetView()->GetContainerBounds(&container_bounds);
   AutocompleteActionPredictorFactory::GetForProfile(profile_)->
       StartPrerendering(match.destination_url,
-                        tab->web_contents()->GetController()
-                            .GetSessionStorageNamespaceMap(),
+                        tab->GetController().GetSessionStorageNamespaceMap(),
                         container_bounds.size());
 }
 
 void OmniboxEditModel::DoPreconnect(const AutocompleteMatch& match) {
   if (!match.destination_url.SchemeIs(extensions::kExtensionScheme)) {
     // Warm up DNS Prefetch cache, or preconnect to a search service.
     UMA_HISTOGRAM_ENUMERATION("Autocomplete.MatchType", match.type,
                               AutocompleteMatch::NUM_TYPES);
     if (profile_->GetNetworkPredictor()) {
       profile_->GetNetworkPredictor()->AnticipateOmniboxUrl(
@@ skipping 32 matching lines @@
 }
 
 void OmniboxEditModel::ClassifyStringForPasteAndGo(
     const string16& text,
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   DCHECK(match);
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
       string16(), false, false, match, alternate_nav_url);
 }