Remove frontend code that allows for dynamic profile setting, and read the profile off the browse...

chrome/browser/ui/gtk/location_bar_view_gtk.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/gtk/location_bar_view_gtk.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 143 matching lines @@
       enable_location_drag_(false),
       security_info_label_(NULL),
       tab_to_search_alignment_(NULL),
       tab_to_search_box_(NULL),
       tab_to_search_full_label_(NULL),
       tab_to_search_partial_label_(NULL),
       tab_to_search_hint_(NULL),
       tab_to_search_hint_leading_label_(NULL),
       tab_to_search_hint_icon_(NULL),
       tab_to_search_hint_trailing_label_(NULL),
-      profile_(NULL),
       command_updater_(browser->command_updater()),
       toolbar_model_(browser->toolbar_model()),
       browser_(browser),
       disposition_(CURRENT_TAB),
       transition_(PageTransition::TYPED),
       first_run_bubble_(this),
       popup_window_mode_(false),
       theme_service_(NULL),
       hbox_width_(0),
       entry_box_width_(0),
       show_selected_keyword_(false),
       show_keyword_hint_(false) {
 }
 
 LocationBarViewGtk::~LocationBarViewGtk() {
   // All of our widgets should have be children of / owned by the alignment.
   star_.Destroy();
   hbox_.Destroy();
   content_setting_hbox_.Destroy();
   page_action_hbox_.Destroy();
 }
 
 void LocationBarViewGtk::Init(bool popup_window_mode) {
   popup_window_mode_ = popup_window_mode;
 
-  theme_service_ = GtkThemeService::GetFrom(profile_);
+  Profile* profile = browser_->profile();
+  theme_service_ = GtkThemeService::GetFrom(profile);
 
   // Create the widget first, so we can pass it to the OmniboxViewGtk.
   hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding));
   gtk_container_set_border_width(GTK_CONTAINER(hbox_.get()), kHboxBorder);
   // We will paint for the alignment, to paint the background and border.
   gtk_widget_set_app_paintable(hbox_.get(), TRUE);
   // Redraw the whole location bar when it changes size (e.g., when toggling
   // the home button on/off.
   gtk_widget_set_redraw_on_allocate(hbox_.get(), TRUE);
 
   // Now initialize the OmniboxViewGtk.
-  location_entry_.reset(new OmniboxViewGtk(this,
-                                           toolbar_model_,
-                                           profile_,
-                                           command_updater_,
-                                           popup_window_mode_,
-                                           hbox_.get()));
+  location_entry_.reset(new OmniboxViewGtk(this, toolbar_model_, profile,
+      command_updater_, popup_window_mode_, hbox_.get()));
   location_entry_->Init();
 
   g_signal_connect(hbox_.get(), "expose-event",
                    G_CALLBACK(&HandleExposeThunk), this);
 
   BuildSiteTypeArea();
 
   // Put |tab_to_search_box_|, |location_entry_|, and |tab_to_search_hint_| into
   // a sub hbox, so that we can make this part horizontally shrinkable without
   // affecting other elements in the location bar.
@@ skipping 88 matching lines @@
 
   content_setting_hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding + 1));
   gtk_widget_set_name(content_setting_hbox_.get(),
                       "chrome-content-setting-hbox");
   gtk_box_pack_end(GTK_BOX(hbox_.get()), content_setting_hbox_.get(),
                    FALSE, FALSE, 1);
 
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     ContentSettingImageViewGtk* content_setting_view =
         new ContentSettingImageViewGtk(
-            static_cast<ContentSettingsType>(i), this, profile_);
+            static_cast<ContentSettingsType>(i), this);
     content_setting_views_.push_back(content_setting_view);
     gtk_box_pack_end(GTK_BOX(content_setting_hbox_.get()),
                      content_setting_view->widget(), FALSE, FALSE, 0);
   }
 
   page_action_hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding));
   gtk_widget_set_name(page_action_hbox_.get(),
                       "chrome-page-action-hbox");
   gtk_box_pack_end(GTK_BOX(hbox_.get()), page_action_hbox_.get(),
                    FALSE, FALSE, 0);
 
   // Now that we've created the widget hierarchy, connect to the main |hbox_|'s
   // size-allocate so we can do proper resizing and eliding on
   // |security_info_label_|.
   g_signal_connect(hbox_.get(), "size-allocate",
                    G_CALLBACK(&OnHboxSizeAllocateThunk), this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  Source<ThemeService>(theme_service_));
   edit_bookmarks_enabled_.Init(prefs::kEditBookmarksEnabled,
-                               profile_->GetPrefs(), this);
+                               profile->GetPrefs(), this);
 
   theme_service_->InitThemesFor(this);
 }
 
 void LocationBarViewGtk::BuildSiteTypeArea() {
   location_icon_image_ = gtk_image_new();
   gtk_widget_set_name(location_icon_image_, "chrome-location-icon");
 
   GtkWidget* icon_alignment = gtk_alignment_new(0, 0, 1, 1);
   gtk_alignment_set_padding(GTK_ALIGNMENT(icon_alignment), 0, 0, 2, 0);
@@ skipping 58 matching lines @@
   }
 
   gtk_drag_source_set(site_type_event_box_, GDK_BUTTON1_MASK,
                       NULL, 0, GDK_ACTION_COPY);
   ui::SetSourceTargetListFromCodeMask(site_type_event_box_,
                                       ui::TEXT_PLAIN |
                                       ui::TEXT_URI_LIST |
                                       ui::CHROME_NAMED_URL);
 }
 
-void LocationBarViewGtk::SetProfile(Profile* profile) {
-  profile_ = profile;
-}
-
 TabContents* LocationBarViewGtk::GetTabContents() const {
   return browser_->GetSelectedTabContents();
 }
 
 void LocationBarViewGtk::SetPreviewEnabledPageAction(
     ExtensionAction *page_action,
     bool preview_enabled) {
   DCHECK(page_action);
   UpdatePageActions();
   for (ScopedVector<PageActionViewGtk>::iterator iter =
@@ skipping 116 matching lines @@
   DCHECK(toolbar_model_->input_in_progress() != in_progress);
 
   toolbar_model_->set_input_in_progress(in_progress);
   Update(NULL);
 }
 
 void LocationBarViewGtk::OnKillFocus() {
 }
 
 void LocationBarViewGtk::OnSetFocus() {
-  AccessibilityTextBoxInfo info(
-      profile_,
-      l10n_util::GetStringUTF8(IDS_ACCNAME_LOCATION).c_str(),
-      false);
+  Profile* profile = browser_->profile();
+  AccessibilityTextBoxInfo info(profile,
+      l10n_util::GetStringUTF8(IDS_ACCNAME_LOCATION), false);
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_ACCESSIBILITY_CONTROL_FOCUSED,
-      Source<Profile>(profile_),
-      Details<AccessibilityTextBoxInfo>(&info));
+      Source<Profile>(profile), Details<AccessibilityTextBoxInfo>(&info));
 
   // Update the keyword and search hint states.
   OnChanged();
 }
 
 SkBitmap LocationBarViewGtk::GetFavicon() const {
   return GetTabContentsWrapper()->favicon_tab_helper()->GetFavicon();
 }
 
 string16 LocationBarViewGtk::GetTitle() const {
@@ skipping 59 matching lines @@
     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*> page_actions;
-  ExtensionService* service = profile_->GetExtensionService();
+  ExtensionService* service = browser_->profile()->GetExtensionService();
   if (!service)
     return;
 
   // Find all the page actions.
   for (size_t i = 0; i < service->extensions()->size(); ++i) {
     if (service->extensions()->at(i)->page_action())
       page_actions.push_back(service->extensions()->at(i)->page_action());
   }
 
   // Initialize on the first call, or re-inialize if more extensions have been
   // loaded or added after startup.
   if (page_actions.size() != page_action_views_.size()) {
     page_action_views_.reset();  // Delete the old views (if any).
 
     for (size_t i = 0; i < page_actions.size(); ++i) {
       page_action_views_.push_back(
-          new PageActionViewGtk(this, profile_, page_actions[i]));
+          new PageActionViewGtk(this, page_actions[i]));
       gtk_box_pack_end(GTK_BOX(page_action_hbox_.get()),
                        page_action_views_[i]->widget(), FALSE, FALSE, 0);
     }
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
         Source<LocationBar>(this),
         NotificationService::NoDetails());
   }
 
   TabContents* contents = GetTabContents();
@@ skipping 145 matching lines @@
 
   UpdateStarIcon();
   UpdateSiteTypeArea();
   UpdateContentSettingsIcons();
 }
 
 gboolean LocationBarViewGtk::HandleExpose(GtkWidget* widget,
                                           GdkEventExpose* event) {
   // If we're not using GTK theming, draw our own border over the edge pixels
   // of the background.
-  if (!profile_ ||
-      !GtkThemeService::GetFrom(profile_)->UsingNativeTheme()) {
+  if (!GtkThemeService::GetFrom(browser_->profile())->UsingNativeTheme()) {
     int left, center, right;
     if (popup_window_mode_) {
       left = right = IDR_LOCATIONBG_POPUPMODE_EDGE;
       center = IDR_LOCATIONBG_POPUPMODE_CENTER;
     } else {
       left = IDR_LOCATIONBG_L;
       center = IDR_LOCATIONBG_C;
       right = IDR_LOCATIONBG_R;
     }
 
@@ skipping 89 matching lines @@
   gtk_label_set_max_width_chars(GTK_LABEL(security_info_label_),
                                 std::max(10, max_chars));
 
   pango_font_metrics_unref(metrics);
 }
 
 void LocationBarViewGtk::SetKeywordLabel(const string16& keyword) {
   if (keyword.empty())
     return;
 
-  DCHECK(profile_);
+  Profile* profile = browser_->profile();
   TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile_);
+      TemplateURLServiceFactory::GetForProfile(profile);
   if (!template_url_service)
     return;
 
   bool is_extension_keyword;
   const string16 short_name = template_url_service->
       GetKeywordShortName(keyword, &is_extension_keyword);
   int message_id = is_extension_keyword ?
       IDS_OMNIBOX_EXTENSION_KEYWORD_TEXT : IDS_OMNIBOX_KEYWORD_TEXT;
   string16 full_name = l10n_util::GetStringFUTF16(message_id,
                                                   short_name);
   string16 partial_name = l10n_util::GetStringFUTF16(
       message_id,
       WideToUTF16Hack(
           location_bar_util::CalculateMinString(UTF16ToWideHack(short_name))));
   gtk_label_set_text(GTK_LABEL(tab_to_search_full_label_),
                      UTF16ToUTF8(full_name).c_str());
   gtk_label_set_text(GTK_LABEL(tab_to_search_partial_label_),
                      UTF16ToUTF8(partial_name).c_str());
 
   if (last_keyword_ != keyword) {
     last_keyword_ = keyword;
 
     if (is_extension_keyword) {
       const TemplateURL* template_url =
           template_url_service->GetTemplateURLForKeyword(keyword);
-      const SkBitmap& bitmap = profile_->GetExtensionService()->
+      const SkBitmap& bitmap = profile->GetExtensionService()->
           GetOmniboxIcon(template_url->GetExtensionId());
       GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&bitmap);
       gtk_image_set_from_pixbuf(GTK_IMAGE(tab_to_search_magnifier_), pixbuf);
       g_object_unref(pixbuf);
     } else {
       ResourceBundle& rb = ResourceBundle::GetSharedInstance();
       gtk_image_set_from_pixbuf(GTK_IMAGE(tab_to_search_magnifier_),
                                 rb.GetNativeImageNamed(IDR_OMNIBOX_SEARCH));
     }
   }
 }
 
 void LocationBarViewGtk::SetKeywordHintLabel(const string16& keyword) {
   if (keyword.empty())
     return;
 
-  DCHECK(profile_);
   TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile_);
+      TemplateURLServiceFactory::GetForProfile(browser_->profile());
   if (!template_url_service)
     return;
 
   bool is_extension_keyword;
   const string16 short_name = template_url_service->
       GetKeywordShortName(keyword, &is_extension_keyword);
   int message_id = is_extension_keyword ?
       IDS_OMNIBOX_EXTENSION_KEYWORD_HINT : IDS_OMNIBOX_KEYWORD_HINT;
   std::vector<size_t> content_param_offsets;
   const string16 keyword_hint = l10n_util::GetStringFUTF16(
@@ skipping 18 matching lines @@
 }
 
 void LocationBarViewGtk::ShowFirstRunBubbleInternal(
     FirstRun::BubbleType bubble_type) {
   if (!location_entry_.get() || !widget()->window)
     return;
 
   gfx::Rect bounds = gtk_util::WidgetBounds(location_icon_image_);
   bounds.set_x(bounds.x() + kFirstRunBubbleLeftSpacing);
 
-  FirstRunBubble::Show(profile_, location_icon_image_, bounds, bubble_type);
+  FirstRunBubble::Show(browser_->profile(), location_icon_image_, bounds,
+                       bubble_type);
 }
 
 gboolean LocationBarViewGtk::OnIconReleased(GtkWidget* sender,
                                             GdkEventButton* event) {
   TabContents* tab = GetTabContents();
 
   if (event->button == 1) {
     // Do not show page info if the user has been editing the location
     // bar, or the location bar is at the NTP.
     if (location_entry()->IsEditingOrEmpty())
@@ skipping 14 matching lines @@
   } else if (event->button == 2) {
     // When the user middle clicks on the location icon, try to open the
     // contents of the PRIMARY selection in the current tab.
     // If the click was outside our bounds, do nothing.
     if (!gtk_util::WidgetBounds(sender).Contains(
             gfx::Point(event->x, event->y))) {
       return FALSE;
     }
 
     GURL url;
-    if (!gtk_util::URLFromPrimarySelection(profile_, &url))
+    if (!gtk_util::URLFromPrimarySelection(browser_->profile(), &url))
       return FALSE;
 
     tab->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED);
     return TRUE;
   }
 
   return FALSE;
 }
 
 void LocationBarViewGtk::OnIconDragData(GtkWidget* sender,
@@ skipping 48 matching lines @@
     return FALSE;
   }
   return TRUE;
 }
 
 void LocationBarViewGtk::ShowStarBubble(const GURL& url,
                                         bool newly_bookmarked) {
   if (!star_.get())
     return;
 
-  BookmarkBubbleGtk::Show(star_.get(), profile_, url, newly_bookmarked);
+  BookmarkBubbleGtk::Show(star_.get(), browser_->profile(), url,
+                          newly_bookmarked);
 }
 
 void LocationBarViewGtk::SetStarred(bool starred) {
   if (starred == starred_)
     return;
 
   starred_ = starred;
   UpdateStarIcon();
 }
 
@@ skipping 76 matching lines @@
       gtk_widget_show(tab_to_search_hint_trailing_label_);
       gtk_widget_show(tab_to_search_hint_);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk::ContentSettingImageViewGtk
 LocationBarViewGtk::ContentSettingImageViewGtk::ContentSettingImageViewGtk(
     ContentSettingsType content_type,
-    const LocationBarViewGtk* parent,
-    Profile* profile)
+    const LocationBarViewGtk* parent)
     : content_setting_image_model_(
           ContentSettingImageModel::CreateContentSettingImageModel(
               content_type)),
       alignment_(gtk_alignment_new(0, 0, 1, 1)),
       event_box_(gtk_event_box_new()),
       hbox_(gtk_hbox_new(FALSE, kInnerPadding)),
       image_(gtk_image_new()),
       label_(gtk_label_new(NULL)),
       parent_(parent),
-      profile_(profile),
       content_setting_bubble_(NULL),
       animation_(this),
       method_factory_(this) {
   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment_.get()), 1, 1, 0, 0);
   gtk_container_add(GTK_CONTAINER(alignment_.get()), event_box_.get());
 
   // 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 30 matching lines @@
 
 void LocationBarViewGtk::ContentSettingImageViewGtk::UpdateFromTabContents(
     TabContents* tab_contents) {
   content_setting_image_model_->UpdateFromTabContents(tab_contents);
   if (!content_setting_image_model_->is_visible()) {
     gtk_widget_hide(widget());
     return;
   }
 
   gtk_image_set_from_pixbuf(GTK_IMAGE(image_.get()),
-      GtkThemeService::GetFrom(profile_)->GetPixbufNamed(
+      GtkThemeService::GetFrom(parent_->browser()->profile())->GetPixbufNamed(
           content_setting_image_model_->get_icon()));
 
   gtk_widget_set_tooltip_text(widget(),
       content_setting_image_model_->get_tooltip().c_str());
   gtk_widget_show_all(widget());
 
   TabSpecificContentSettings* content_settings = NULL;
   if (tab_contents) {
     content_settings = TabContentsWrapper::GetCurrentWrapperForContents(
         tab_contents)->content_settings();
@@ skipping 63 matching lines @@
 
 void LocationBarViewGtk::ContentSettingImageViewGtk::AnimationCanceled(
     const ui::Animation* animation) {
 }
 
 gboolean LocationBarViewGtk::ContentSettingImageViewGtk::OnButtonPressed(
     GtkWidget* sender, GdkEvent* event) {
   TabContentsWrapper* tab_contents = parent_->GetTabContentsWrapper();
   if (!tab_contents)
     return TRUE;
+  Profile* profile = parent_->browser()->profile();
   content_setting_bubble_ = new ContentSettingBubbleGtk(
       sender, this,
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-          parent_->browser(), tab_contents, profile_,
+          parent_->browser(), tab_contents, profile,
           content_setting_image_model_->get_content_settings_type()),
-      profile_, tab_contents->tab_contents());
+      profile, tab_contents->tab_contents());
   return TRUE;
 }
 
 gboolean LocationBarViewGtk::ContentSettingImageViewGtk::OnExpose(
     GtkWidget* sender, GdkEventExpose* event) {
   if (!(animation_.IsShowing() || animation_.IsClosing()))
     return FALSE;
 
   const int height = sender->allocation.height;
 
@@ skipping 22 matching lines @@
 void LocationBarViewGtk::ContentSettingImageViewGtk::BubbleClosing(
     BubbleGtk* bubble,
     bool closed_by_escape) {
   content_setting_bubble_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk::PageActionViewGtk
 
 LocationBarViewGtk::PageActionViewGtk::PageActionViewGtk(
-    LocationBarViewGtk* owner, Profile* profile,
+    LocationBarViewGtk* owner,
     ExtensionAction* page_action)
     : owner_(NULL),
-      profile_(profile),
       page_action_(page_action),
       last_icon_pixbuf_(NULL),
       tracker_(this),
       preview_enabled_(false) {
   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);
   g_signal_connect_after(event_box_.get(), "expose-event",
                          G_CALLBACK(OnExposeEventThunk), this);
 
   image_.Own(gtk_image_new());
   gtk_container_add(GTK_CONTAINER(event_box_.get()), image_.get());
 
-  const Extension* extension = profile->GetExtensionService()->
-      GetExtensionById(page_action->extension_id(), false);
+  const Extension* extension = owner->browser()->profile()->
+      GetExtensionService()->GetExtensionById(page_action->extension_id(),
+                                              false);
   DCHECK(extension);
 
   // Load all the icons declared in the manifest. This is the contents of the
   // icons array, plus the default_icon property, if any.
   std::vector<std::string> icon_paths(*page_action->icon_paths());
   if (!page_action_->default_icon_path().empty())
     icon_paths.push_back(page_action_->default_icon_path());
 
   for (std::vector<std::string>::iterator iter = icon_paths.begin();
        iter != icon_paths.end(); ++iter) {
@@ skipping 135 matching lines @@
       page_action_->GetPopupUrl(current_tab_id_),
       owner_->browser_,
       event_box_.get(),
       devtools);
   return true;
 }
 
 gboolean LocationBarViewGtk::PageActionViewGtk::OnButtonPressed(
     GtkWidget* sender,
     GdkEventButton* event) {
+  Profile* profile = owner_->browser()->profile();
   if (event->button != 3) {
     if (!ShowPopup(false)) {
-      ExtensionService* service = profile_->GetExtensionService();
-      service->browser_event_router()->PageActionExecuted(
-          profile_,
-          page_action_->extension_id(),
-          page_action_->id(),
-          current_tab_id_,
-          current_url_.spec(),
-          event->button);
+      ExtensionService* service = profile->GetExtensionService();
+      service->browser_event_router()->PageActionExecuted(profile,
+          page_action_->extension_id(), page_action_->id(), current_tab_id_,
+          current_url_.spec(), event->button);
     }
   } else {
-    const Extension* extension = profile_->GetExtensionService()->
+    const Extension* extension = profile->GetExtensionService()->
         GetExtensionById(page_action()->extension_id(), false);
 
     if (extension->ShowConfigureContextMenus()) {
       context_menu_model_ =
           new ExtensionContextMenuModel(extension, owner_->browser_, this);
       context_menu_.reset(
           new MenuGtk(NULL, context_menu_model_.get()));
       context_menu_->PopupForWidget(sender, event->button, event->time);
     }
   }
 
   return TRUE;
 }
 
 gboolean LocationBarViewGtk::PageActionViewGtk::OnExposeEvent(
-    GtkWidget* widget, GdkEventExpose* event) {
+    GtkWidget* widget,
+    GdkEventExpose* event) {
   TabContents* contents = owner_->GetTabContents();
   if (!contents)
     return FALSE;
 
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   if (tab_id < 0)
     return FALSE;
 
   std::string badge_text = page_action_->GetBadgeText(tab_id);
   if (badge_text.empty())
     return FALSE;
 
   gfx::CanvasSkiaPaint canvas(event, false);
   gfx::Rect bounding_rect(widget->allocation);
   page_action_->PaintBadge(&canvas, bounding_rect, tab_id);
   return FALSE;
 }