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();
+  RemoveAllButtons();
   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());
+
+  AddCoreButtons();
+  // 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 87 matching lines @@
   if (slide_animation_.IsShowing() &&
       animate_type == BookmarkBar::ANIMATE_STATE_CHANGE) {
     slide_animation_.Hide();
   } else {
     gtk_widget_hide(bookmark_hbox_);
     slide_animation_.Reset(0);
     AnimationProgressed(&slide_animation_);
   }
 }
 
-void BookmarkBarGtk::CreateAllBookmarkButtons() {
-  const BookmarkNode* bar = model_->bookmark_bar_node();
-  DCHECK(bar && model_->other_node());
-
-  // Create a button for each of the children on the bookmark bar.
-  for (int i = 0; i < bar->child_count(); ++i) {
-    const BookmarkNode* node = bar->GetChild(i);
-    GtkToolItem* item = CreateBookmarkToolItem(node);
-    gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
-    if (node->is_folder())
-      menu_bar_helper_.Add(gtk_bin_get_child(GTK_BIN(item)));
-  }
-
-  bookmark_utils::ConfigureButtonForNode(model_->other_node(),
-      model_, other_bookmarks_button_, theme_service_);
-
-  SetInstructionState();
-  SetChevronState();
-}
-
 void BookmarkBarGtk::SetInstructionState() {
   if (model_)
     show_instructions_ = model_->bookmark_bar_node()->empty();
 
   gtk_widget_set_visible(bookmark_toolbar_.get(), !show_instructions_);
   gtk_widget_set_visible(instructions_, show_instructions_);
 }
 
 void BookmarkBarGtk::SetChevronState() {
   if (!gtk_widget_get_visible(bookmark_hbox_))
@@ skipping 17 matching lines @@
 
 void BookmarkBarGtk::UpdateOtherBookmarksVisibility() {
   bool has_other_children = !model_->other_node()->empty();
   if (has_other_children == gtk_widget_get_visible(other_bookmarks_button_))
     return;
 
   gtk_widget_set_visible(other_bookmarks_button_, has_other_children);
   gtk_widget_set_visible(other_bookmarks_separator_, has_other_children);
 }
 
-void BookmarkBarGtk::RemoveAllBookmarkButtons() {
+void BookmarkBarGtk::RemoveAllButtons() {
   gtk_util::RemoveAllChildren(bookmark_toolbar_.get());
   menu_bar_helper_.Clear();
+}
+
+void BookmarkBarGtk::AddCoreButtons() {
   menu_bar_helper_.Add(other_bookmarks_button_);
   menu_bar_helper_.Add(overflow_button_);
 }
 
+void BookmarkBarGtk::ResetButtons() {
+  RemoveAllButtons();
+  AddCoreButtons();
+
+  const BookmarkNode* bar = model_->bookmark_bar_node();
+  DCHECK(bar && model_->other_node());
+
+  // Create a button for each of the children on the bookmark bar.
+  for (int i = 0; i < bar->child_count(); ++i) {
+    const BookmarkNode* node = bar->GetChild(i);
+    GtkToolItem* item = CreateBookmarkToolItem(node);
+    gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
+    if (node->is_folder())
+      menu_bar_helper_.Add(gtk_bin_get_child(GTK_BIN(item)));
+  }
+
+  bookmark_utils::ConfigureButtonForNode(model_->other_node(),
+      model_, other_bookmarks_button_, theme_service_);
+
+  SetInstructionState();
+  SetChevronState();
+}
+
 int BookmarkBarGtk::GetBookmarkButtonCount() {
   GList* children = gtk_container_get_children(
       GTK_CONTAINER(bookmark_toolbar_.get()));
   int count = g_list_length(children);
   g_list_free(children);
   return count;
 }
 
 void BookmarkBarGtk::SetOverflowButtonAppearance() {
   GtkWidget* former_child = gtk_bin_get_child(GTK_BIN(overflow_button_));
@@ skipping 263 matching lines @@
                                       NULL, 0);
 }
 
 void BookmarkBarGtk::Loaded(BookmarkModel* model, bool ids_reassigned) {
   // If |instructions_| has been nulled, we are in the middle of browser
   // shutdown. Do nothing.
   if (!instructions_)
     return;
 
   UpdateOtherBookmarksVisibility();
-  RemoveAllBookmarkButtons();
-  CreateAllBookmarkButtons();
+  ResetButtons();
 }
 
 void BookmarkBarGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // The bookmark model should never be deleted before us. This code exists
   // to check for regressions in shutdown code and not crash.
   if (!browser_shutdown::ShuttingDownWithoutClosingBrowsers())
     NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
@@ skipping 74 matching lines @@
 void BookmarkBarGtk::BookmarkNodeFaviconChanged(BookmarkModel* model,
                                                 const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                    const BookmarkNode* node) {
   if (node != model_->bookmark_bar_node())
     return;  // We only care about reordering of the bookmark bar node.
 
-  // Purge and rebuild the bar.
-  RemoveAllBookmarkButtons();
-  CreateAllBookmarkButtons();
+  ResetButtons();
 }
 
 void BookmarkBarGtk::Observe(int type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED) {
     if (model_ && model_->IsLoaded()) {
       // Regenerate the bookmark bar with all new objects with their theme
       // properties set correctly for the new theme.
-      RemoveAllBookmarkButtons();
-      CreateAllBookmarkButtons();
+      ResetButtons();
     }
 
     // Resize the bookmark bar since the target height may have changed.
     AnimationProgressed(&slide_animation_);
 
     UpdateEventBoxPaintability();
 
     GdkColor paint_box_color =
         theme_service_->GetGdkColor(ThemeService::COLOR_TOOLBAR);
     gtk_widget_modify_bg(paint_box_, GTK_STATE_NORMAL, &paint_box_color);
@@ skipping 136 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);
 }