Removing instances of profile_->GetBookmarkModel() as part of converting BookmarkModel to a PKS.

chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.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/views/bookmarks/bookmark_menu_delegate.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/event_disposition.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/event_utils.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/page_navigator.h"
@@ skipping 28 matching lines @@
       menu_(NULL),
       for_drop_(false),
       parent_menu_item_(NULL),
       next_menu_id_(first_menu_id),
       real_delegate_(NULL),
       is_mutating_model_(false),
       location_(bookmark_utils::LAUNCH_NONE){
 }
 
 BookmarkMenuDelegate::~BookmarkMenuDelegate() {
-  profile_->GetBookmarkModel()->RemoveObserver(this);
+  BookmarkModelFactory::GetForProfile(profile_)->RemoveObserver(this);
 }
 
 void BookmarkMenuDelegate::Init(
     views::MenuDelegate* real_delegate,
     MenuItemView* parent,
     const BookmarkNode* node,
     int start_child_index,
     ShowOptions show_options,
     bookmark_utils::BookmarkLaunchLocation location) {
-  profile_->GetBookmarkModel()->AddObserver(this);
+  BookmarkModelFactory::GetForProfile(profile_)->AddObserver(this);
   real_delegate_ = real_delegate;
   if (parent) {
     parent_menu_item_ = parent;
     int initial_count = parent->GetSubmenu() ?
         parent->GetSubmenu()->GetMenuItemCount() : 0;
     if ((start_child_index < node->child_count()) &&
         (initial_count > 0)) {
       parent->AppendSeparator();
     }
     BuildMenu(node, start_child_index, parent, &next_menu_id_);
@@ skipping 106 matching lines @@
     const views::DropTargetEvent& event,
     views::MenuDelegate::DropPosition* position) {
   // Should only get here if we have drop data.
   DCHECK(drop_data_.is_valid());
 
   const BookmarkNode* node = menu_id_to_node_map_[item->GetCommand()];
   const BookmarkNode* drop_parent = node->parent();
   int index_to_drop_at = drop_parent->GetIndexOf(node);
   switch (*position) {
     case views::MenuDelegate::DROP_AFTER:
-      if (node == profile_->GetBookmarkModel()->other_node() ||
-          node == profile_->GetBookmarkModel()->mobile_node()) {
+      if (node == BookmarkModelFactory::GetForProfile(
+              profile_)->other_node() ||
+          node == BookmarkModelFactory::GetForProfile(
+              profile_)->mobile_node()) {
         // Dropping after these nodes makes no sense.
         *position = views::MenuDelegate::DROP_NONE;
       }
       index_to_drop_at++;
       break;
 
     case views::MenuDelegate::DROP_BEFORE:
-      if (node == profile_->GetBookmarkModel()->mobile_node()) {
+      if (node == BookmarkModelFactory::GetForProfile(
+              profile_)->mobile_node()) {
         // Dropping before this node makes no sense.
         *position = views::MenuDelegate::DROP_NONE;
       }
       index_to_drop_at++;
       break;
 
     case views::MenuDelegate::DROP_ON:
       drop_parent = node;
       index_to_drop_at = node->child_count();
       break;
 
     default:
       break;
   }
   DCHECK(drop_parent);
   return bookmark_utils::BookmarkDropOperation(
       profile_, event, drop_data_, drop_parent, index_to_drop_at);
 }
 
 int BookmarkMenuDelegate::OnPerformDrop(
     MenuItemView* menu,
     views::MenuDelegate::DropPosition position,
     const views::DropTargetEvent& event) {
   const BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
   DCHECK(drop_node);
-  BookmarkModel* model = profile_->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
   DCHECK(model);
   const BookmarkNode* drop_parent = drop_node->parent();
   DCHECK(drop_parent);
   int index_to_drop_at = drop_parent->GetIndexOf(drop_node);
   switch (position) {
     case views::MenuDelegate::DROP_AFTER:
       index_to_drop_at++;
       break;
 
     case views::MenuDelegate::DROP_ON:
@@ skipping 21 matching lines @@
 }
 
 bool BookmarkMenuDelegate::ShowContextMenu(MenuItemView* source,
                                            int id,
                                            const gfx::Point& p,
                                            bool is_mouse_gesture) {
   DCHECK(menu_id_to_node_map_.find(id) != menu_id_to_node_map_.end());
   std::vector<const BookmarkNode*> nodes;
   nodes.push_back(menu_id_to_node_map_[id]);
   bool close_on_delete = !parent_menu_item_ &&
-      (nodes[0]->parent() == profile()->GetBookmarkModel()->other_node() &&
+      (nodes[0]->parent() == BookmarkModelFactory::GetForProfile(
+          profile())->other_node() &&
        nodes[0]->parent()->child_count() == 1);
   context_menu_.reset(
       new BookmarkContextMenu(
           parent_,
           browser_,
           profile_,
           page_navigator_,
           nodes[0]->parent(),
           nodes,
           close_on_delete));
   context_menu_->set_observer(this);
   context_menu_->RunMenuAt(p);
   context_menu_.reset(NULL);
   return true;
 }
 
 bool BookmarkMenuDelegate::CanDrag(MenuItemView* menu) {
   const BookmarkNode* node = menu_id_to_node_map_[menu->GetCommand()];
   // Don't let users drag the other folder.
-  return node->parent() != profile_->GetBookmarkModel()->root_node();
+  return node->parent() != BookmarkModelFactory::GetForProfile(
+      profile_)->root_node();
 }
 
 void BookmarkMenuDelegate::WriteDragData(MenuItemView* sender,
                                          ui::OSExchangeData* data) {
   DCHECK(sender && data);
 
   content::RecordAction(UserMetricsAction("BookmarkBar_DragFromFolder"));
 
   BookmarkNodeData drag_data(menu_id_to_node_map_[sender->GetCommand()]);
   drag_data.Write(profile_, data);
@@ skipping 40 matching lines @@
   }
 }
 
 void BookmarkMenuDelegate::WillRemoveBookmarks(
     const std::vector<const BookmarkNode*>& bookmarks) {
   DCHECK(!is_mutating_model_);
   is_mutating_model_ = true;
 
   // Remove the observer so that when the remove happens we don't prematurely
   // cancel the menu. The observer ias added back in DidRemoveBookmarks.
-  profile_->GetBookmarkModel()->RemoveObserver(this);
+  BookmarkModelFactory::GetForProfile(profile_)->RemoveObserver(this);
 
   // Remove the menu items.
   std::set<MenuItemView*> changed_parent_menus;
   for (std::vector<const BookmarkNode*>::const_iterator i(bookmarks.begin());
        i != bookmarks.end(); ++i) {
     NodeToMenuIDMap::iterator node_to_menu = node_to_menu_id_map_.find(*i);
     if (node_to_menu != node_to_menu_id_map_.end()) {
       MenuItemView* menu = GetMenuByID(node_to_menu->second);
       DCHECK(menu);  // If there an entry in node_to_menu_id_map_, there should
                      // be a menu.
@@ skipping 28 matching lines @@
     }
     if (ancestor_removed)
       node_to_menu_id_map_.erase(i++);
     else
       ++i;
   }
 }
 
 void BookmarkMenuDelegate::DidRemoveBookmarks() {
   // Balances remove in WillRemoveBookmarksImpl.
-  profile_->GetBookmarkModel()->AddObserver(this);
+  BookmarkModelFactory::GetForProfile(profile_)->AddObserver(this);
   DCHECK(is_mutating_model_);
   is_mutating_model_ = false;
 }
 
 MenuItemView* BookmarkMenuDelegate::CreateMenu(const BookmarkNode* parent,
                                                int start_child_index,
                                                ShowOptions show_options) {
   MenuItemView* menu = new MenuItemView(real_delegate_);
   menu->SetCommand(next_menu_id_++);
   menu_id_to_node_map_[menu->GetCommand()] = parent;
   menu->set_has_icons(true);
   BuildMenu(parent, start_child_index, menu, &next_menu_id_);
   if (show_options == SHOW_PERMANENT_FOLDERS)
     BuildMenusForPermanentNodes(menu, &next_menu_id_);
   node_to_menu_map_[parent] = menu;
   return menu;
 }
 
 void BookmarkMenuDelegate::BuildMenusForPermanentNodes(
     views::MenuItemView* menu,
     int* next_menu_id) {
-  BookmarkModel* model = profile_->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
   bool added_separator = false;
   BuildMenuForPermanentNode(model->other_node(), menu, next_menu_id,
                             &added_separator);
   BuildMenuForPermanentNode(model->mobile_node(), menu, next_menu_id,
                             &added_separator);
 }
 
 void BookmarkMenuDelegate::BuildMenuForPermanentNode(
     const BookmarkNode* node,
     MenuItemView* menu,
@@ skipping 21 matching lines @@
                                      MenuItemView* menu,
                                      int* next_menu_id) {
   DCHECK(parent->empty() || start_child_index < parent->child_count());
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (int i = start_child_index; i < parent->child_count(); ++i) {
     const BookmarkNode* node = parent->GetChild(i);
     int id = *next_menu_id;
 
     (*next_menu_id)++;
     if (node->is_url()) {
-      const gfx::Image& image = profile_->GetBookmarkModel()->GetFavicon(node);
+      const gfx::Image& image = BookmarkModelFactory::GetForProfile(
+          profile_)->GetFavicon(node);
       const gfx::ImageSkia* icon = image.IsEmpty() ?
           rb.GetImageSkiaNamed(IDR_DEFAULT_FAVICON) : image.ToImageSkia();
       menu->AppendMenuItemWithIcon(id, node->GetTitle(), *icon);
       node_to_menu_id_map_[node] = id;
     } else if (node->is_folder()) {
       gfx::ImageSkia* folder_icon =
           rb.GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER);
       MenuItemView* submenu = menu->AppendSubMenuWithIcon(
           id, node->GetTitle(), *folder_icon);
       node_to_menu_id_map_[node] = id;
       BuildMenu(node, 0, submenu, next_menu_id);
     } else {
       NOTREACHED();
     }
     menu_id_to_node_map_[id] = node;
   }
 }
 
 MenuItemView* BookmarkMenuDelegate::GetMenuByID(int id) {
   for (NodeToMenuMap::const_iterator i(node_to_menu_map_.begin());
        i != node_to_menu_map_.end(); ++i) {
     MenuItemView* menu = i->second->GetMenuItemByID(id);
     if (menu)
       return menu;
   }
 
   return parent_menu_item_ ? parent_menu_item_->GetMenuItemByID(id) : NULL;
 }