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

chrome/browser/ui/views/bookmarks/bookmark_bar_view.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/views/bookmarks/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 344 matching lines @@
 
 // Returns the bitmap to use for starred folders.
 static const SkBitmap& GetFolderIcon() {
   if (!kFolderIcon) {
     kFolderIcon = ResourceBundle::GetSharedInstance().
         GetBitmapNamed(IDR_BOOKMARK_BAR_FOLDER);
   }
   return *kFolderIcon;
 }
 
-BookmarkBarView::BookmarkBarView(Profile* profile, Browser* browser)
-    : profile_(NULL),
-      page_navigator_(NULL),
+BookmarkBarView::BookmarkBarView(Browser* browser)
+    : page_navigator_(NULL),
       model_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(show_folder_method_factory_(this)),
       sync_error_button_(NULL),
-      sync_service_(NULL),
+      sync_service_(browser->profile()->GetProfileSyncService()),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false) {
-  if (profile->GetProfileSyncService()) {
-    // Obtain a pointer to the profile sync service and add our instance as an
-    // observer.
-    sync_service_ = profile->GetProfileSyncService();
+  if (sync_service_)
     sync_service_->AddObserver(this);
-  }
 
   set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
-  SetProfile(profile);
 
   size_animation_->Reset(1);
 }
 
 BookmarkBarView::~BookmarkBarView() {
   if (model_)
     model_->RemoveObserver(this);
 
   // It's possible for the menu to outlive us, reset the observer to make sure
   // it doesn't have a reference to us.
   if (bookmark_menu_)
     bookmark_menu_->set_observer(NULL);
 
   StopShowFolderDropMenuTimer();
 
   if (sync_service_)
     sync_service_->RemoveObserver(this);
 }
 
-void BookmarkBarView::SetProfile(Profile* profile) {
-  DCHECK(profile);
-  if (profile_ == profile)
-    return;
-
-  StopThrobbing(true);
-
-  // Cancels the current cancelable.
-  registrar_.RemoveAll();
-
-  profile_ = profile;
-
-  if (model_)
-    model_->RemoveObserver(this);
-
-  // Disable the other bookmarked button, we'll re-enable when the model is
-  // loaded.
-  other_bookmarked_button_->SetEnabled(false);
-
-  Source<Profile> ns_source(profile_->GetOriginalProfile());
-  registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_SHOWN, ns_source);
-  registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_HIDDEN, ns_source);
-
-  // Remove any existing bookmark buttons.
-  while (GetBookmarkButtonCount())
-    delete child_at(0);
-
-  model_ = profile_->GetBookmarkModel();
-  if (model_) {
-    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 BookmarkBarView::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
 }
 
 void BookmarkBarView::SetBookmarkBarState(
     BookmarkBar::State state,
     BookmarkBar::AnimateChangeType animate_type) {
   if (animate_type == BookmarkBar::ANIMATE_STATE_CHANGE) {
     animating_detached_ = (state == BookmarkBar::DETACHED ||
                            bookmark_bar_state_ == BookmarkBar::DETACHED);
@@ skipping 259 matching lines @@
   custom_formats->insert(BookmarkNodeData::GetBookmarkCustomFormat());
   return true;
 }
 
 bool BookmarkBarView::AreDropTypesRequired() {
   return true;
 }
 
 bool BookmarkBarView::CanDrop(const ui::OSExchangeData& data) {
   if (!model_ || !model_->IsLoaded() ||
-      !profile_->GetPrefs()->GetBoolean(prefs::kEditBookmarksEnabled))
+      !browser_->profile()->GetPrefs()->GetBoolean(
+          prefs::kEditBookmarksEnabled))
     return false;
 
   if (!drop_info_.get())
     drop_info_.reset(new DropInfo());
 
   // Only accept drops of 1 node, which is the case for all data dragged from
   // bookmark bar and menus.
   return drop_info_->data.Read(data) && drop_info_->data.size() == 1;
 }
 
@@ skipping 91 matching lines @@
     index = parent_node->child_count();
   } else if (drop_info_->location.on) {
     parent_node = root->GetChild(index);
     index = parent_node->child_count();
   } else {
     parent_node = root;
   }
   const BookmarkNodeData data = drop_info_->data;
   DCHECK(data.is_valid());
   drop_info_.reset();
-  return bookmark_utils::PerformBookmarkDrop(profile_, data, parent_node,
-                                             index);
+  return bookmark_utils::PerformBookmarkDrop(browser_->profile(), data,
+                                             parent_node, index);
 }
 
 void BookmarkBarView::ShowContextMenu(const gfx::Point& p,
                                       bool is_mouse_gesture) {
   ShowContextMenuForView(this, p, is_mouse_gesture);
 }
 
 void BookmarkBarView::OnThemeChanged() {
   UpdateColors();
 }
@@ skipping 160 matching lines @@
     // Don't let the user drag while animating open or we're closed (and not
     // detached, when detached size_animation_ is always 0). This typically is
     // only hit if the user does something to inadvertently trigger DnD such as
     // pressing the mouse and hitting control-b.
     return ui::DragDropTypes::DRAG_NONE;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
       return bookmark_utils::BookmarkDragOperation(
-          profile_, model_->bookmark_bar_node()->GetChild(i));
+          browser_->profile(), model_->bookmark_bar_node()->GetChild(i));
     }
   }
   NOTREACHED();
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 bool BookmarkBarView::CanStartDragForView(views::View* sender,
                                           const gfx::Point& press_pt,
                                           const gfx::Point& p) {
   // Check if we have not moved enough horizontally but we have moved downward
@@ skipping 25 matching lines @@
     node = model_->other_node();
   } else if (view == overflow_button_) {
     node = model_->bookmark_bar_node();
     start_index = GetFirstHiddenNodeIndex();
   } else {
     int button_index = GetIndexOf(view);
     DCHECK_NE(-1, button_index);
     node = model_->bookmark_bar_node()->GetChild(button_index);
   }
 
-  bookmark_menu_ = new BookmarkMenuController(
-      profile_, page_navigator_, GetWidget(), node, start_index);
+  bookmark_menu_ = new BookmarkMenuController(browser_->profile(),
+      page_navigator_, GetWidget(), node, start_index);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const views::Event& event) {
   // Show the login wizard if the user clicked the re-login button.
   if (sender->tag() == kSyncErrorButtonTag) {
     DCHECK(sender == sync_error_button_);
     DCHECK(sync_service_ && !sync_service_->IsManaged());
     sync_service_->ShowErrorUI();
     return;
   }
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
   WindowOpenDisposition disposition_from_event_flags =
       event_utils::DispositionFromEventFlags(sender->mouse_event_flags());
 
+  Profile* profile = browser_->profile();
   if (node->is_url()) {
-    RecordAppLaunch(profile_, node->url());
+    RecordAppLaunch(profile, node->url());
     page_navigator_->OpenURL(node->url(), GURL(),
         disposition_from_event_flags, PageTransition::AUTO_BOOKMARK);
   } else {
-    bookmark_utils::OpenAll(GetWidget()->GetNativeWindow(), profile_,
+    bookmark_utils::OpenAll(GetWidget()->GetNativeWindow(), profile,
         page_navigator_, node, disposition_from_event_flags);
   }
   UserMetrics::RecordAction(UserMetricsAction("ClickedBookmarkBarURLButton"));
 }
 
 void BookmarkBarView::ShowContextMenuForView(View* source,
                                              const gfx::Point& p,
                                              bool is_mouse_gesture) {
   if (!model_->IsLoaded()) {
     // Don't do anything if the model isn't loaded.
@@ skipping 14 matching lines @@
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     const BookmarkNode* node =
         model_->bookmark_bar_node()->GetChild(bookmark_button_index);
     nodes.push_back(node);
     parent = node->parent();
   } else {
     parent = model_->bookmark_bar_node();
     nodes.push_back(parent);
   }
-  // Browser may be null during testing.
-  PageNavigator* navigator =
-      browser() ? browser()->GetSelectedTabContents() : NULL;
+  Profile* profile = browser_->profile();
   bool close_on_remove =
-      (parent == profile_->GetBookmarkModel()->other_node() &&
-       parent->child_count() == 1);
-  BookmarkContextMenu controller(GetWidget(), profile_,
-                                 navigator, parent, nodes, close_on_remove);
+      (parent == profile->GetBookmarkModel()->other_node()) &&
+      (parent->child_count() == 1);
+  BookmarkContextMenu controller(GetWidget(), profile,
+      browser_->GetSelectedTabContents(), parent, nodes, close_on_remove);
   controller.RunMenuAt(p);
 }
 
 void BookmarkBarView::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
-  DCHECK(profile_);
+  DCHECK(browser_->profile());
   switch (type) {
     case chrome::NOTIFICATION_BOOKMARK_BUBBLE_SHOWN: {
       StopThrobbing(true);
       GURL url = *(Details<GURL>(details).ptr());
       const BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(url);
       if (!node)
         return;  // Generally shouldn't happen.
       StartThrobbing(node, false);
       break;
     }
@@ skipping 20 matching lines @@
 
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
   sync_error_button_ = CreateSyncErrorButton();
   AddChildView(sync_error_button_);
 
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
   other_bookmarked_button_ = CreateOtherBookmarkedButton();
+  // We'll re-enable when the model is loaded.
+  other_bookmarked_button_->SetEnabled(false);
   AddChildView(other_bookmarked_button_);
 
   bookmarks_separator_view_ = new ButtonSeparatorView();
   AddChildView(bookmarks_separator_view_);
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
   size_animation_.reset(new ui::SlideAnimation(this));
+
+  Profile* profile = browser_->profile();
+  Source<Profile> ns_source(profile->GetOriginalProfile());
+  registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_SHOWN, ns_source);
+  registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_HIDDEN, ns_source);
+
+  model_ = profile->GetBookmarkModel();
+  if (model_) {
+    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.
+  }
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
   // We contain five non-bookmark button views: other bookmarks, bookmarks
   // separator, chevrons (for overflow), the instruction label and the sync
   // error button.
   return child_count() - 5;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
@@ skipping 60 matching lines @@
   sync_error_button->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_SYNC_ERROR_BUTTON));
   sync_error_button->SetIcon(
       *ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING));
   return sync_error_button;
 }
 
 views::View* BookmarkBarView::CreateBookmarkButton(const BookmarkNode* node) {
   if (node->is_url()) {
     BookmarkButton* button = new BookmarkButton(this, node->url(),
-        UTF16ToWide(node->GetTitle()), profile_);
+        UTF16ToWide(node->GetTitle()), browser_->profile());
     ConfigureButton(node, button);
     return button;
   } else {
     views::MenuButton* button = new BookmarkFolderButton(this,
         UTF16ToWide(node->GetTitle()), this, false);
     button->SetIcon(GetFolderIcon());
     ConfigureButton(node, button);
     return button;
   }
 }
@@ skipping 92 matching lines @@
 
   views::MenuButton* menu_button = GetMenuButtonForNode(node);
   if (!menu_button)
     return;
 
   int start_index = 0;
   if (node == model_->bookmark_bar_node())
     start_index = GetFirstHiddenNodeIndex();
 
   drop_info_->is_menu_showing = true;
-  bookmark_drop_menu_ = new BookmarkMenuController(
-      profile_, page_navigator_, GetWidget(), node, start_index);
+  bookmark_drop_menu_ = new BookmarkMenuController(browser_->profile(),
+      page_navigator_, GetWidget(), node, start_index);
   bookmark_drop_menu_->set_observer(this);
   bookmark_drop_menu_->RunMenuAt(this, true);
 }
 
 void BookmarkBarView::StopShowFolderDropMenuTimer() {
   show_folder_method_factory_.RevokeAll();
 }
 
 void BookmarkBarView::StartShowFolderDropMenuTimer(const BookmarkNode* node) {
   if (testing_) {
@@ skipping 21 matching lines @@
 
   // The drop event uses the screen coordinates while the child Views are
   // always laid out from left to right (even though they are rendered from
   // right-to-left on RTL locales). Thus, in order to make sure the drop
   // coordinates calculation works, we mirror the event's X coordinate if the
   // locale is RTL.
   int mirrored_x = GetMirroredXInView(event.x());
 
   bool found = false;
   const int other_delta_x = mirrored_x - other_bookmarked_button_->x();
+  Profile* profile = browser_->profile();
   if (other_bookmarked_button_->IsVisible() && other_delta_x >= 0 &&
       other_delta_x < other_bookmarked_button_->width()) {
     // Mouse is over 'other' folder.
     location->button_type = DROP_OTHER_FOLDER;
     location->on = true;
     found = true;
   } else if (!GetBookmarkButtonCount()) {
     // No bookmarks, accept the drop.
     location->index = 0;
-    int ops = data.GetFirstNode(profile_)
-        ? ui::DragDropTypes::DRAG_MOVE
-        : ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
+    int ops = data.GetFirstNode(profile) ? ui::DragDropTypes::DRAG_MOVE :
+        ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
     location->operation =
         bookmark_utils::PreferredDropOperation(event.source_operations(), ops);
     return;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
        GetBookmarkButton(i)->IsVisible() && !found; i++) {
     views::TextButton* button = GetBookmarkButton(i);
     int button_x = mirrored_x - button->x();
     int button_w = button->width();
@@ skipping 42 matching lines @@
     } else {
       return;
     }
   }
 
   if (location->on) {
     const BookmarkNode* parent = (location->button_type == DROP_OTHER_FOLDER) ?
         model_->other_node() :
         model_->bookmark_bar_node()->GetChild(location->index);
     location->operation =
-        bookmark_utils::BookmarkDropOperation(profile_, event, data, parent,
+        bookmark_utils::BookmarkDropOperation(profile, event, data, parent,
                                               parent->child_count());
     if (!location->operation && !data.has_single_url() &&
-        data.GetFirstNode(profile_) == parent) {
+        data.GetFirstNode(profile) == parent) {
       // Don't open a menu if the node being dragged is the menu to open.
       location->on = false;
     }
   } else {
-    location->operation =
-        bookmark_utils::BookmarkDropOperation(profile_, event, data,
-                                              model_->bookmark_bar_node(),
-                                              location->index);
+    location->operation = bookmark_utils::BookmarkDropOperation(profile, event,
+        data, model_->bookmark_bar_node(), location->index);
   }
 }
 
 void BookmarkBarView::WriteBookmarkDragData(const BookmarkNode* node,
                                             ui::OSExchangeData* data) {
   DCHECK(node && data);
   BookmarkNodeData drag_data(node);
-  drag_data.Write(profile_, data);
+  drag_data.Write(browser_->profile(), data);
 }
 
 void BookmarkBarView::StartThrobbing(const BookmarkNode* node,
                                      bool overflow_only) {
   DCHECK(!throbbing_view_);
 
   // Determine which visible button is showing the bookmark (or is an ancestor
   // of the bookmark).
   const BookmarkNode* bbn = model_->bookmark_bar_node();
   const BookmarkNode* parent_on_bb = node;
@@ skipping 210 matching lines @@
               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(
           static_cast<int>(
               browser_defaults::kBookmarkBarHeight *
               size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }