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

chrome/browser/ui/gtk/bookmarks/bookmark_bar_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/bookmarks/bookmark_bar_gtk.h"
 
 #include <vector>
 
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
@@ skipping 103 matching lines @@
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram,
                             extension_misc::APP_LAUNCH_BOOKMARK_BAR,
                             extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
 }
 
 }  // namespace
 
 const int BookmarkBarGtk::kBookmarkBarNTPHeight = 57;
 
 BookmarkBarGtk::BookmarkBarGtk(BrowserWindowGtk* window,
-                               Profile* profile, Browser* browser,
+                               Browser* browser,
                                TabstripOriginProvider* tabstrip_origin_provider)
-    : profile_(NULL),
-      page_navigator_(NULL),
+    : page_navigator_(NULL),
       browser_(browser),
       window_(window),
       tabstrip_origin_provider_(tabstrip_origin_provider),
       model_(NULL),
       instructions_(NULL),
       sync_service_(NULL),
       dragged_node_(NULL),
       drag_icon_(NULL),
       toolbar_drop_item_(NULL),
-      theme_service_(GtkThemeService::GetFrom(profile)),
+      theme_service_(GtkThemeService::GetFrom(browser->profile())),
       show_instructions_(true),
       menu_bar_helper_(this),
       slide_animation_(this),
       last_allocation_width_(-1),
       throbbing_widget_(NULL),
       method_factory_(this),
       bookmark_bar_state_(BookmarkBar::DETACHED) {
+  Profile* profile = browser->profile();
   if (profile->GetProfileSyncService()) {
     // Obtain a pointer to the profile sync service and add our instance as an
     // observer.
     sync_service_ = profile->GetProfileSyncService();
     sync_service_->AddObserver(this);
   }
 
-  Init(profile);
-  SetProfile(profile);
+  Init();
   // Force an update by simulating being in the wrong state.
   // BrowserWindowGtk sets our true state after we're created.
   SetBookmarkBarState(BookmarkBar::SHOW,
                       BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  Source<ThemeService>(theme_service_));
 
   edit_bookmarks_enabled_.Init(prefs::kEditBookmarksEnabled,
-                               profile_->GetPrefs(), this);
+                               profile->GetPrefs(), this);
   OnEditBookmarksEnabledChanged();
 }
 
 BookmarkBarGtk::~BookmarkBarGtk() {
   RemoveAllBookmarkButtons();
   bookmark_toolbar_.Destroy();
   event_box_.Destroy();
 }
 
-void BookmarkBarGtk::SetProfile(Profile* profile) {
-  DCHECK(profile);
-  if (profile_ == profile)
-    return;
-
-  RemoveAllBookmarkButtons();
-
-  profile_ = profile;
-
-  if (model_)
-    model_->RemoveObserver(this);
-
-  // TODO(erg): Handle extensions
-
-  model_ = profile_->GetBookmarkModel();
-  model_->AddObserver(this);
-  if (model_->IsLoaded())
-    Loaded(model_, false);
-
-  // else case: we'll receive notification back from the BookmarkModel when done
-  // loading, then we'll populate the bar.
-}
-
 void BookmarkBarGtk::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
 }
 
-void BookmarkBarGtk::Init(Profile* profile) {
+void BookmarkBarGtk::Init() {
   event_box_.Own(gtk_event_box_new());
   g_signal_connect(event_box_.get(), "destroy",
                    G_CALLBACK(&OnEventBoxDestroyThunk), this);
   g_signal_connect(event_box_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressedThunk), this);
 
   ntp_padding_box_ = gtk_alignment_new(0, 0, 1, 1);
   gtk_container_add(GTK_CONTAINER(event_box_.get()), ntp_padding_box_);
 
   paint_box_ = gtk_event_box_new();
   gtk_container_add(GTK_CONTAINER(ntp_padding_box_), paint_box_);
   GdkColor paint_box_color =
       theme_service_->GetGdkColor(ThemeService::COLOR_TOOLBAR);
   gtk_widget_modify_bg(paint_box_, GTK_STATE_NORMAL, &paint_box_color);
   gtk_widget_add_events(paint_box_, GDK_POINTER_MOTION_MASK |
                                     GDK_BUTTON_PRESS_MASK);
 
   bookmark_hbox_ = gtk_hbox_new(FALSE, 0);
   gtk_container_add(GTK_CONTAINER(paint_box_), bookmark_hbox_);
 
   instructions_ = gtk_alignment_new(0, 0, 1, 1);
   gtk_alignment_set_padding(GTK_ALIGNMENT(instructions_), 0, 0,
                             kInstructionsPadding, 0);
+  Profile* profile = browser_->profile();
   instructions_gtk_.reset(new BookmarkBarInstructionsGtk(this, profile));
   gtk_container_add(GTK_CONTAINER(instructions_), instructions_gtk_->widget());
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), instructions_,
                      TRUE, TRUE, 0);
 
   gtk_drag_dest_set(instructions_,
       GtkDestDefaults(GTK_DEST_DEFAULT_DROP | GTK_DEST_DEFAULT_MOTION),
       NULL, 0, kDragAction);
   ui::SetDestTargetList(instructions_, kDestTargetList);
   g_signal_connect(instructions_, "drag-data-received",
@@ skipping 69 matching lines @@
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), sync_error_button_,
                      FALSE, FALSE, 0);
 
   gtk_widget_set_size_request(event_box_.get(), -1, kBookmarkBarMinimumHeight);
 
   ViewIDUtil::SetID(other_bookmarks_button_, VIEW_ID_OTHER_BOOKMARKS);
   ViewIDUtil::SetID(widget(), VIEW_ID_BOOKMARK_BAR);
 
   gtk_widget_show_all(widget());
   gtk_widget_hide(widget());
+
+  RemoveAllBookmarkButtons();

[sky, 2011/08/08 16:02:29]

I don't think you need this anymore. It made sense in SetProfile, but not at
init time.

[Peter Kasting, 2011/08/08 17:52:07]

Unfortunately this function does more than removing all the buttons -- it also
adds back the "other bookmarks" and overflow buttons.

I think I'll rename it, though I don't know to what.

+  // TODO(erg): Handle extensions
+  model_ = profile->GetBookmarkModel();
+  model_->AddObserver(this);
+  if (model_->IsLoaded())
+    Loaded(model_, false);
+  // else case: we'll receive notification back from the BookmarkModel when done
+  // loading, then we'll populate the bar.
 }
 
 void BookmarkBarGtk::SetBookmarkBarState(
     BookmarkBar::State state,
     BookmarkBar::AnimateChangeType animate_type) {
   if (animate_type == BookmarkBar::ANIMATE_STATE_CHANGE &&
       (state == BookmarkBar::DETACHED ||
        bookmark_bar_state_ == BookmarkBar::DETACHED)) {
     // TODO(estade): animate the transition between detached and non or remove
     // detached entirely.
@@ skipping 68 matching lines @@
       return;
   } else {
     // Overflow exists: don't show anything for an overflowed folder button.
     if (button != overflow_button_ && button != other_bookmarks_button_ &&
         node->parent()->GetIndexOf(node) >= first_hidden) {
       return;
     }
   }
 
   current_menu_.reset(
-      new BookmarkMenuController(browser_, profile_, page_navigator_,
+      new BookmarkMenuController(browser_, browser_->profile(), page_navigator_,
                                  GTK_WINDOW(gtk_widget_get_toplevel(button)),
                                  node,
                                  button == overflow_button_ ?
                                      first_hidden : 0));
   menu_bar_helper_.MenuStartedShowing(button, current_menu_->widget());
   GdkEvent* event = gtk_get_current_event();
   current_menu_->Popup(button, event->button.button, event->button.time);
   gdk_event_free(event);
 }
 
@@ skipping 700 matching lines @@
     nodes.push_back(node);
     parent = node->parent();
   } else {
     parent = model_->bookmark_bar_node();
     nodes.push_back(parent);
   }
 
   GtkWindow* window = GTK_WINDOW(gtk_widget_get_toplevel(sender));
   current_context_menu_controller_.reset(
       new BookmarkContextMenuController(
-          window, this, profile_, page_navigator_, parent, nodes));
+          window, this, browser_->profile(), page_navigator_, parent, nodes));
   current_context_menu_.reset(
       new MenuGtk(NULL, current_context_menu_controller_->menu_model()));
   current_context_menu_->PopupAsContext(
       gfx::Point(event->x_root, event->y_root),
       event->time);
 }
 
 gboolean BookmarkBarGtk::OnButtonPressed(GtkWidget* sender,
                                          GdkEventButton* event) {
   last_pressed_coordinates_ = gfx::Point(event->x, event->y);
@@ skipping 17 matching lines @@
 
   return FALSE;
 }
 
 void BookmarkBarGtk::OnClicked(GtkWidget* sender) {
   const BookmarkNode* node = GetNodeForToolButton(sender);
   DCHECK(node);
   DCHECK(node->is_url());
   DCHECK(page_navigator_);
 
-  RecordAppLaunch(profile_, node->url());
-  bookmark_utils::OpenAll(window_->GetNativeHandle(),
-                          profile_, page_navigator_, node,
-                          gtk_util::DispositionForCurrentButtonPressEvent());
+  Profile* profile = browser_->profile();
+  RecordAppLaunch(profile, node->url());
+  bookmark_utils::OpenAll(window_->GetNativeHandle(), profile, page_navigator_,
+      node, gtk_util::DispositionForCurrentButtonPressEvent());
 
   UserMetrics::RecordAction(UserMetricsAction("ClickedBookmarkBarURLButton"));
 }
 
 void BookmarkBarGtk::OnButtonDragBegin(GtkWidget* button,
                                        GdkDragContext* drag_context) {
   // The parent tool item might be removed during the drag. Ref it so |button|
   // won't get destroyed.
   g_object_ref(button->parent);
 
@@ skipping 39 matching lines @@
   DCHECK(dragged_node_);
   dragged_node_ = NULL;
 
   DCHECK(drag_icon_);
   gtk_widget_destroy(drag_icon_);
   drag_icon_ = NULL;
 
   g_object_unref(button->parent);
 }
 
-void BookmarkBarGtk::OnButtonDragGet(GtkWidget* widget, GdkDragContext* context,
+void BookmarkBarGtk::OnButtonDragGet(GtkWidget* widget,
+                                     GdkDragContext* context,
                                      GtkSelectionData* selection_data,
-                                     guint target_type, guint time) {
+                                     guint target_type,
+                                     guint time) {
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget);
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
-                                           profile_);
+                                           browser_->profile());
 }
 
 void BookmarkBarGtk::OnFolderClicked(GtkWidget* sender) {
   // Stop its throbbing, if any.
   HoverControllerGtk* hover_controller =
       HoverControllerGtk::GetHoverControllerGtk(sender);
   if (hover_controller)
     hover_controller->StartThrobbing(0);
 
   GdkEvent* event = gtk_get_current_event();
   if (event->button.button == 1) {
     PopupForButton(sender);
   } else if (event->button.button == 2) {
     const BookmarkNode* node = GetNodeForToolButton(sender);
-    bookmark_utils::OpenAll(window_->GetNativeHandle(),
-                            profile_, page_navigator_,
-                            node, NEW_BACKGROUND_TAB);
+    bookmark_utils::OpenAll(window_->GetNativeHandle(), browser_->profile(),
+                            page_navigator_, node, NEW_BACKGROUND_TAB);
   }
 }
 
 gboolean BookmarkBarGtk::OnToolbarDragMotion(GtkWidget* toolbar,
                                              GdkDragContext* context,
                                              gint x,
                                              gint y,
                                              guint time) {
   gint index = gtk_toolbar_get_drop_index(GTK_TOOLBAR(toolbar), x, y);
   return ItemDraggedOverToolbar(context, index, time);
@@ skipping 41 matching lines @@
       dest_node = GetNodeForToolButton(widget);
       index = dest_node->child_count();
     }
   }
 
   switch (target_type) {
     case ui::CHROME_BOOKMARK_ITEM: {
       std::vector<const BookmarkNode*> nodes =
           bookmark_utils::GetNodesFromSelection(context, selection_data,
                                                 target_type,
-                                                profile_,
+                                                browser_->profile(),
                                                 &delete_selection_data,
                                                 &dnd_success);
       DCHECK(!nodes.empty());
       for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
            it != nodes.end(); ++it) {
         model_->Move(*it, dest_node, index);
         index = dest_node->GetIndexOf(*it) + 1;
       }
       break;
     }
@@ skipping 153 matching lines @@
 void BookmarkBarGtk::OnEditBookmarksEnabledChanged() {
   GtkDestDefaults dest_defaults =
       *edit_bookmarks_enabled_ ? GTK_DEST_DEFAULT_ALL :
                                  GTK_DEST_DEFAULT_DROP;
   gtk_drag_dest_set(overflow_button_, dest_defaults, NULL, 0, kDragAction);
   gtk_drag_dest_set(other_bookmarks_button_, dest_defaults,
                     NULL, 0, kDragAction);
   ui::SetDestTargetList(overflow_button_, kDestTargetList);
   ui::SetDestTargetList(other_bookmarks_button_, kDestTargetList);
 }