Remove TabContents from OmniboxEditController and friends.

chrome/browser/ui/gtk/location_bar_view_gtk.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/gtk/location_bar_view_gtk.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 47 matching lines @@
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/nine_box.h"
 #include "chrome/browser/ui/gtk/omnibox/omnibox_view_gtk.h"
 #include "chrome/browser/ui/gtk/rounded_window.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/browser/ui/gtk/zoom_bubble_gtk.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/omnibox/location_bar_util.h"
 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
-#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/webui/extensions/extension_info_ui.h"
 #include "chrome/browser/ui/zoom/zoom_controller.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/navigation_entry.h"
@@ skipping 94 matching lines @@
 }
 
 class ContentSettingImageViewGtk : public LocationBarViewGtk::PageToolViewGtk,
                                    public BubbleDelegateGtk {
  public:
   ContentSettingImageViewGtk(ContentSettingsType content_type,
                              const LocationBarViewGtk* parent);
   virtual ~ContentSettingImageViewGtk();
 
   // PageToolViewGtk
-  virtual void Update(TabContents* tab_contents) OVERRIDE;
+  virtual void Update(WebContents* web_contents) OVERRIDE;
 
   // ui::AnimationDelegate
   virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE;
 
  private:
   // PageToolViewGtk
   virtual GdkColor button_border_color() const OVERRIDE;
   virtual GdkColor gradient_top_color() const OVERRIDE;
   virtual GdkColor gradient_bottom_color() const OVERRIDE;
   virtual void OnClick(GtkWidget* sender) OVERRIDE;
@@ skipping 19 matching lines @@
               content_type)),
       content_setting_bubble_(NULL) {
   animation_.SetSlideDuration(kContentSettingImageAnimationTime);
 }
 
 ContentSettingImageViewGtk::~ContentSettingImageViewGtk() {
   if (content_setting_bubble_)
     content_setting_bubble_->Close();
 }
 
-void ContentSettingImageViewGtk::Update(
-    TabContents* tab_contents) {
-  if (tab_contents) {
-    content_setting_image_model_->UpdateFromWebContents(
-        tab_contents->web_contents());
-  }
+void ContentSettingImageViewGtk::Update(WebContents* web_contents) {
+  if (web_contents)
+    content_setting_image_model_->UpdateFromWebContents(web_contents);
+
   if (!content_setting_image_model_->is_visible()) {
     gtk_widget_hide(widget());
     return;
   }
 
   gtk_image_set_from_pixbuf(GTK_IMAGE(image_.get()),
       GtkThemeService::GetFrom(parent_->browser()->profile())->GetImageNamed(
           content_setting_image_model_->get_icon()).ToGdkPixbuf());
 
   gtk_widget_set_tooltip_text(widget(),
       content_setting_image_model_->get_tooltip().c_str());
   gtk_widget_show_all(widget());
 
-  if (!tab_contents)
+  if (!web_contents)
     return;
 
   TabSpecificContentSettings* content_settings =
-      TabSpecificContentSettings::FromWebContents(tab_contents->web_contents());
+      TabSpecificContentSettings::FromWebContents(web_contents);
   if (!content_settings || content_settings->IsBlockageIndicated(
       content_setting_image_model_->get_content_settings_type()))
     return;
 
   // The content blockage was not yet indicated to the user. Start indication
   // animation and clear "not yet shown" flag.
   content_settings->SetBlockageHasBeenIndicated(
       content_setting_image_model_->get_content_settings_type());
 
   int label_string_id =
@@ skipping 32 matching lines @@
   return kContentSettingTopColor;
 }
 
 GdkColor ContentSettingImageViewGtk::
     gradient_bottom_color() const {
   return kContentSettingBottomColor;
 }
 
 void ContentSettingImageViewGtk::OnClick(
     GtkWidget* sender) {
-  TabContents* tab_contents = parent_->GetTabContents();
-  if (!tab_contents)
+  WebContents* web_contents = parent_->GetWebContents();
+  if (!web_contents)
     return;
   Profile* profile = parent_->browser()->profile();
   content_setting_bubble_ = new ContentSettingBubbleGtk(
       sender, this,
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
           parent_->browser()->content_setting_bubble_model_delegate(),
-          tab_contents->web_contents(),
+          web_contents,
           profile,
           content_setting_image_model_->get_content_settings_type()),
-      profile, tab_contents->web_contents());
+      profile, web_contents);
   return;
 }
 
 void ContentSettingImageViewGtk::BubbleClosing(
     BubbleGtk* bubble,
     bool closed_by_escape) {
   content_setting_bubble_ = NULL;
 }
 
 class WebIntentsButtonViewGtk : public LocationBarViewGtk::PageToolViewGtk {
  public:
   explicit WebIntentsButtonViewGtk(const LocationBarViewGtk* parent)
       : LocationBarViewGtk::PageToolViewGtk(parent) {
     animation_.SetSlideDuration(kWebIntentsButtonAnimationTime);
   }
   virtual ~WebIntentsButtonViewGtk() {}
 
   // PageToolViewGtk
-  virtual void Update(TabContents* tab_contents) OVERRIDE;
+  virtual void Update(WebContents* web_contents) OVERRIDE;
 
  private:
   // PageToolViewGtk
   virtual GdkColor button_border_color() const OVERRIDE;
   virtual GdkColor gradient_top_color() const OVERRIDE;
   virtual GdkColor gradient_bottom_color() const OVERRIDE;
   virtual void OnClick(GtkWidget* sender) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(WebIntentsButtonViewGtk);
 };
 
-void WebIntentsButtonViewGtk::Update(TabContents* tab_contents) {
+void WebIntentsButtonViewGtk::Update(WebContents* web_contents) {
   WebIntentPickerController* web_intent_picker_controller =
-      tab_contents ? WebIntentPickerController::FromWebContents(
-                         tab_contents->web_contents())
+      web_contents ? WebIntentPickerController::FromWebContents(web_contents)
                    : NULL;
   if (!web_intent_picker_controller ||
       !web_intent_picker_controller->ShowLocationBarPickerButton()) {
     gtk_widget_hide(widget());
     return;
   }
 
   gtk_widget_set_tooltip_text(widget(),
       l10n_util::GetStringUTF8(IDS_INTENT_PICKER_USE_ANOTHER_SERVICE).c_str());
   gtk_widget_show_all(widget());
 
   gtk_label_set_text(GTK_LABEL(label_.get()),
       l10n_util::GetStringUTF8(IDS_INTENT_PICKER_USE_ANOTHER_SERVICE).c_str());
 
   StartAnimating();
 }
 
 void WebIntentsButtonViewGtk::OnClick(GtkWidget* sender) {
-  TabContents* tab_contents = parent_->GetTabContents();
-  if (!tab_contents)
+  WebContents* web_contents = parent_->GetWebContents();
+  if (!web_contents)
     return;
 
-  WebIntentPickerController::FromWebContents(tab_contents->web_contents())->
+  WebIntentPickerController::FromWebContents(web_contents)->
       LocationBarPickerButtonClicked();
 }
 
 GdkColor WebIntentsButtonViewGtk::button_border_color() const {
   return kGrayBorderColor;
 }
 
 GdkColor WebIntentsButtonViewGtk::gradient_top_color() const {
   return kTopColorGray;
 }
@@ skipping 509 matching lines @@
 }
 
 string16 LocationBarViewGtk::GetTitle() const {
   return GetWebContents()->GetTitle();
 }
 
 InstantController* LocationBarViewGtk::GetInstant() {
   return browser_->instant_controller()->instant();
 }
 
-TabContents* LocationBarViewGtk::GetTabContents() const {
-  return chrome::GetActiveTabContents(browser_);
-}
-
 void LocationBarViewGtk::ShowFirstRunBubble() {
   // We need the browser window to be shown before we can show the bubble, but
   // we get called before that's happened.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&LocationBarViewGtk::ShowFirstRunBubbleInternal,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LocationBarViewGtk::SetInstantSuggestion(
@@ skipping 27 matching lines @@
   location_entry_->SetFocus();
   location_entry_->SetForcedQuery();
 }
 
 void LocationBarViewGtk::UpdateContentSettingsIcons() {
   bool any_visible = false;
   for (ScopedVector<PageToolViewGtk>::iterator i(
            content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     (*i)->Update(
-        toolbar_model_->GetInputInProgress() ? NULL : GetTabContents());
+        toolbar_model_->GetInputInProgress() ? NULL : GetWebContents());
     any_visible = (*i)->IsVisible() || any_visible;
   }
 
   // If there are no visible content things, hide the top level box so it
   // doesn't mess with padding.
   gtk_widget_set_visible(content_setting_hbox_.get(), any_visible);
 }
 
 void LocationBarViewGtk::UpdatePageActions() {
   std::vector<ExtensionAction*> new_page_actions;
@@ skipping 45 matching lines @@
   page_action_views_.clear();
   if (page_action_views_.size() != count_before) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
         content::Source<LocationBar>(this),
         content::NotificationService::NoDetails());
   }
 }
 
 void LocationBarViewGtk::UpdateWebIntentsButton() {
-  web_intents_button_view_->Update(GetTabContents());
+  web_intents_button_view_->Update(GetWebContents());
   gtk_widget_set_visible(web_intents_hbox_.get(),
                          web_intents_button_view_->IsVisible());
 }
 
 void LocationBarViewGtk::UpdateOpenPDFInReaderPrompt() {
   // Not implemented on Gtk.
 }
 
 void LocationBarViewGtk::SaveStateToContents(WebContents* contents) {
   location_entry_->SaveStateToTab(contents);
@@ skipping 66 matching lines @@
   return starred_;
 }
 
 void LocationBarViewGtk::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOCATION_BAR_UPDATED: {
       // Only update if the updated action box was for the active tab contents.
       WebContents* target_tab = content::Details<WebContents>(details).ptr();
-      if (target_tab == GetTabContents()->web_contents())
+      if (target_tab == GetWebContents())
         UpdatePageActions();
       break;
     }
 
     case chrome::NOTIFICATION_BROWSER_THEME_CHANGED: {
       if (theme_service_->UsingNativeTheme()) {
         gtk_widget_modify_bg(tab_to_search_box_, GTK_STATE_NORMAL, NULL);
 
         GdkColor border_color = theme_service_->GetGdkColor(
             ThemeService::COLOR_FRAME);
@@ skipping 452 matching lines @@
 }
 
 void LocationBarViewGtk::ZoomChangedForActiveTab(bool can_show_bubble) {
   UpdateZoomIcon();
 
   if (can_show_bubble && gtk_widget_get_visible(zoom_.get()))
     ShowZoomBubble();
 }
 
 void LocationBarViewGtk::UpdateZoomIcon() {
-  TabContents* tab_contents = GetTabContents();
-  if (!zoom_.get() || !tab_contents)
+  WebContents* web_contents = GetWebContents();
+  if (!zoom_.get() || !web_contents)
     return;
 
   ZoomController* zoom_controller =
-      ZoomController::FromWebContents(tab_contents->web_contents());
+      ZoomController::FromWebContents(web_contents);
   if (!zoom_controller || zoom_controller->IsAtDefaultZoom() ||
       toolbar_model_->GetInputInProgress()) {
     gtk_widget_hide(zoom_.get());
     ZoomBubbleGtk::Close();
     return;
   }
 
   const int zoom_resource = zoom_controller->GetResourceForZoomLevel();
   gtk_image_set_from_pixbuf(GTK_IMAGE(zoom_image_),
       theme_service_->GetImageNamed(zoom_resource).ToGdkPixbuf());
@@ skipping 234 matching lines @@
     LocationBarViewGtk* owner,
     ExtensionAction* page_action)
     : owner_(NULL),
       page_action_(page_action),
       current_tab_id_(-1),
       window_(NULL),
       accel_group_(NULL),
       preview_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(scoped_icon_animation_observer_(
           page_action->GetIconAnimation(
-              SessionID::IdForTab(owner->GetTabContents()->web_contents())),
+              SessionID::IdForTab(owner->GetWebContents())),
           this)) {
   event_box_.Own(gtk_event_box_new());
   gtk_widget_set_size_request(event_box_.get(),
                               Extension::kPageActionIconMaxSize,
                               Extension::kPageActionIconMaxSize);
 
   // Make the event box not visible so it does not paint a background.
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
   g_signal_connect(event_box_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressedThunk), this);
@@ skipping 61 matching lines @@
   if (visible != old_visible) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
         content::Source<ExtensionAction>(page_action_),
         content::Details<WebContents>(contents));
   }
 }
 
 void LocationBarViewGtk::PageActionViewGtk::OnIconUpdated() {
   // If we have no owner, that means this class is still being constructed.
-  TabContents* tab_contents = owner_ ? owner_->GetTabContents() : NULL;
-  if (tab_contents)
-    UpdateVisibility(tab_contents->web_contents(), current_url_);
+  WebContents* web_contents = owner_ ? owner_->GetWebContents() : NULL;
+  if (web_contents)
+    UpdateVisibility(web_contents, current_url_);
 }
 
 void LocationBarViewGtk::PageActionViewGtk::TestActivatePageAction() {
   GdkEventButton event = {};
   event.type = GDK_BUTTON_PRESS;
   event.button = 1;
   OnButtonPressed(widget(), &event);
 }
 
 void LocationBarViewGtk::PageActionViewGtk::Observe(
@@ skipping 102 matching lines @@
 
 gboolean LocationBarViewGtk::PageActionViewGtk::OnButtonPressed(
     GtkWidget* sender,
     GdkEventButton* event) {
   // Double and triple-clicks generate both a GDK_BUTTON_PRESS and a
   // GDK_[23]BUTTON_PRESS event. We don't want to double-trigger by acting on
   // both.
   if (event->type != GDK_BUTTON_PRESS)
     return TRUE;
 
-  TabContents* tab_contents = owner_->GetTabContents();
-  if (!tab_contents)
+  WebContents* web_contents = owner_->GetWebContents();
+  if (!web_contents)
     return TRUE;
 
   ExtensionService* extension_service =
       owner_->browser()->profile()->GetExtensionService();
   if (!extension_service)
     return TRUE;
 
   const Extension* extension =
       extension_service->extensions()->GetByID(page_action()->extension_id());
   if (!extension)
     return TRUE;
 
   LocationBarController* controller =
-      extensions::TabHelper::FromWebContents(tab_contents->web_contents())->
+      extensions::TabHelper::FromWebContents(web_contents)->
           location_bar_controller();
 
   switch (controller->OnClicked(extension->id(), event->button)) {
     case LocationBarController::ACTION_NONE:
       break;
 
     case LocationBarController::ACTION_SHOW_POPUP:
       ExtensionPopupGtk::Show(
           page_action_->GetPopupUrl(current_tab_id_),
           owner_->browser_,
@@ skipping 66 matching lines @@
 }
 
 void LocationBarViewGtk::PageActionViewGtk::InspectPopup(
     ExtensionAction* action) {
   ExtensionPopupGtk::Show(
       action->GetPopupUrl(current_tab_id_),
       owner_->browser_,
       event_box_.get(),
       ExtensionPopupGtk::SHOW_AND_INSPECT);
 }