Cleanup redundant model_ field in BookmarkBarView.

chrome/browser/ui/views/bookmarks/bookmark_bar_view.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_bar_view.h"
 
 #include <algorithm>
 #include <limits>
-#include <set>
+#include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar_constants.h"
 #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h"
@@ skipping 402 matching lines @@
 static const gfx::ImageSkia& GetFolderIcon() {
   if (!kFolderIcon) {
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     kFolderIcon = rb->GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER);
   }
   return *kFolderIcon;
 }
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
-      model_(NULL),
       client_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
       managed_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       show_folder_method_factory_(this),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false) {
   set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
 
   size_animation_->Reset(1);
 }
 
 BookmarkBarView::~BookmarkBarView() {
-  if (model_)
-    model_->RemoveObserver(this);
+  if (client_)
+    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);
     bookmark_menu_->SetPageNavigator(NULL);
     bookmark_menu_->clear_bookmark_bar();
   }
   if (context_menu_.get())
     context_menu_->SetPageNavigator(NULL);
@@ skipping 59 matching lines @@
       managed_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return client_->managed_node();
   }
 
   // Check the buttons first.
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
       break;
     if (child->bounds().Contains(adjusted_loc))
-      return model_->bookmark_bar_node()->GetChild(i);
+      return model()->bookmark_bar_node()->GetChild(i);
   }
 
   // Then the overflow button.
   if (overflow_button_->visible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *model_start_index = GetFirstHiddenNodeIndex();
-    return model_->bookmark_bar_node();
+    return model()->bookmark_bar_node();
   }
 
   // And finally the other folder.
   if (other_bookmarked_button_->visible() &&
       other_bookmarked_button_->bounds().Contains(adjusted_loc)) {
-    return model_->other_node();
+    return model()->other_node();
   }
 
   return NULL;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == client_->managed_node())
     return managed_bookmarks_button_;
-  if (node == model_->other_node())
+  if (node == model()->other_node())
     return other_bookmarked_button_;
-  if (node == model_->bookmark_bar_node())
+  if (node == model()->bookmark_bar_node())
     return overflow_button_;
-  int index = model_->bookmark_bar_node()->GetIndexOf(node);
+  int index = model()->bookmark_bar_node()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
     return NULL;
   return static_cast<views::MenuButton*>(child_at(index));
 }
 
 void BookmarkBarView::GetAnchorPositionForButton(
     views::MenuButton* button,
     views::MenuAnchorPosition* anchor) {
   if (button == other_bookmarked_button_ || button == overflow_button_)
     *anchor = views::MENU_ANCHOR_TOPRIGHT;
@@ skipping 219 matching lines @@
     indicator_bounds.set_x(GetMirroredXForRect(indicator_bounds));
 
     // TODO(sky/glen): make me pretty!
     canvas->FillRect(indicator_bounds, kDropIndicatorColor);
   }
 }
 
 bool BookmarkBarView::GetDropFormats(
       int* formats,
       std::set<ui::OSExchangeData::CustomFormat>* custom_formats) {
-  if (!model_ || !model_->loaded())
+  if (!client_ || !model()->loaded())
     return false;
   *formats = ui::OSExchangeData::URL;
   custom_formats->insert(BookmarkNodeData::GetBookmarkCustomFormat());
   return true;
 }
 
 bool BookmarkBarView::AreDropTypesRequired() {
   return true;
 }
 
 bool BookmarkBarView::CanDrop(const ui::OSExchangeData& data) {
-  if (!model_ || !model_->loaded() ||
+  if (!client_ || !model()->loaded() ||
       !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 36 matching lines @@
   if (drop_info_->is_menu_showing) {
     if (bookmark_drop_menu_)
       bookmark_drop_menu_->Cancel();
     drop_info_->is_menu_showing = false;
   }
 
   if (location.on || location.button_type == DROP_OVERFLOW ||
       location.button_type == DROP_OTHER_FOLDER) {
     const BookmarkNode* node;
     if (location.button_type == DROP_OTHER_FOLDER)
-      node = model_->other_node();
+      node = model()->other_node();
     else if (location.button_type == DROP_OVERFLOW)
-      node = model_->bookmark_bar_node();
+      node = model()->bookmark_bar_node();
     else
-      node = model_->bookmark_bar_node()->GetChild(location.index);
+      node = model()->bookmark_bar_node()->GetChild(location.index);
     StartShowFolderDropMenuTimer(node);
   }
 
   return drop_info_->location.operation;
 }
 
 void BookmarkBarView::OnDragExited() {
   StopShowFolderDropMenuTimer();
 
   // NOTE: we don't hide the menu on exit as it's possible the user moved the
@@ skipping 12 matching lines @@
   StopShowFolderDropMenuTimer();
 
   if (bookmark_drop_menu_)
     bookmark_drop_menu_->Cancel();
 
   if (!drop_info_.get() || !drop_info_->location.operation)
     return ui::DragDropTypes::DRAG_NONE;
 
   const BookmarkNode* root =
       (drop_info_->location.button_type == DROP_OTHER_FOLDER) ?
-      model_->other_node() : model_->bookmark_bar_node();
+      model()->other_node() : model()->bookmark_bar_node();
   int index = drop_info_->location.index;
 
   if (index != -1) {
     // TODO(sky): optimize the SchedulePaint region.
     SchedulePaint();
   }
   const BookmarkNode* parent_node;
   if (drop_info_->location.button_type == DROP_OTHER_FOLDER) {
     parent_node = root;
     index = parent_node->child_count();
@@ skipping 56 matching lines @@
   } else if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     UMA_HISTOGRAM_COUNTS("Import.ShowDialog.FromFloatingBookmarkBarView",
                          time_from_install);
   }
 
   chrome::ShowImportDialog(browser_);
 }
 
 void BookmarkBarView::OnBookmarkBubbleShown(const GURL& url) {
   StopThrobbing(true);
-  const BookmarkNode* node = model_->GetMostRecentlyAddedUserNodeForURL(url);
+  const BookmarkNode* node = model()->GetMostRecentlyAddedUserNodeForURL(url);
   if (!node)
     return;  // Generally shouldn't happen.
   StartThrobbing(node, false);
 }
 
 void BookmarkBarView::OnBookmarkBubbleHidden() {
   StopThrobbing(false);
 }
 
 void BookmarkBarView::BookmarkModelLoaded(BookmarkModel* model,
                                           bool ids_reassigned) {
   // There should be no buttons. If non-zero it means Load was invoked more than
   // once, or we didn't properly clear things. Either of which shouldn't happen.
   DCHECK_EQ(0, GetBookmarkButtonCount());
-  const BookmarkNode* node = model_->bookmark_bar_node();
+  const BookmarkNode* node = model->bookmark_bar_node();
   DCHECK(node);
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0, child_count = node->child_count(); i < child_count; ++i)
     AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
-  DCHECK(model_->other_node());
-  other_bookmarked_button_->SetAccessibleName(model_->other_node()->GetTitle());
-  other_bookmarked_button_->SetText(model_->other_node()->GetTitle());
+  DCHECK(model->other_node());
+  other_bookmarked_button_->SetAccessibleName(model->other_node()->GetTitle());
+  other_bookmarked_button_->SetText(model->other_node()->GetTitle());
   managed_bookmarks_button_->SetAccessibleName(
       client_->managed_node()->GetTitle());
   managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
   UpdateColors();
   UpdateButtonsVisibility();
   other_bookmarked_button_->SetEnabled(true);
   managed_bookmarks_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   // Do minimal cleanup, presumably we'll be deleted shortly.
-  model_->RemoveObserver(this);
-  model_ = NULL;
+  model->RemoveObserver(this);
   client_ = NULL;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   bool was_throbbing = throbbing_view_ &&
       throbbing_view_ == DetermineViewToThrobFromRemove(old_parent, old_index);
@@ skipping 38 matching lines @@
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeChanged(BookmarkModel* model,
                                           const BookmarkNode* node) {
   BookmarkNodeChangedImpl(model, node);
 }
 
 void BookmarkBarView::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                     const BookmarkNode* node) {
-  if (node != model_->bookmark_bar_node())
+  if (node != model->bookmark_bar_node())
     return;  // We only care about reordering of the bookmark bar node.
 
   // Remove the existing buttons.
   while (GetBookmarkButtonCount()) {
     views::View* button = child_at(0);
     RemoveChildView(button);
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   }
 
   // Create the new buttons.
@@ skipping 17 matching lines @@
 
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
       views::TextButton* button = GetBookmarkButton(i);
       scoped_ptr<gfx::Canvas> canvas(
           views::GetCanvasForDragImage(button->GetWidget(), button->size()));
       button->PaintButton(canvas.get(), views::TextButton::PB_FOR_DRAG);
       drag_utils::SetDragImageOnDataObject(*canvas, button->size(),
                                            press_pt.OffsetFromOrigin(),
                                            data);
-      WriteBookmarkDragData(model_->bookmark_bar_node()->GetChild(i), data);
+      WriteBookmarkDragData(model()->bookmark_bar_node()->GetChild(i), data);
       return;
     }
   }
   NOTREACHED();
 }
 
 int BookmarkBarView::GetDragOperationsForView(View* sender,
                                               const gfx::Point& p) {
   if (size_animation_->is_animating() ||
       (size_animation_->GetCurrentValue() == 0 &&
        bookmark_bar_state_ != BookmarkBar::DETACHED)) {
     // 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 chrome::GetBookmarkDragOperation(
-          browser_->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
   // vertically - downward drag.
   gfx::Vector2d move_offset = p - press_pt;
   gfx::Vector2d horizontal_offset(move_offset.x(), 0);
   if (!View::ExceededDragThreshold(horizontal_offset) && move_offset.y() > 0) {
     for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
       if (sender == GetBookmarkButton(i)) {
-        const BookmarkNode* node = model_->bookmark_bar_node()->GetChild(i);
+        const BookmarkNode* node = model()->bookmark_bar_node()->GetChild(i);
         // If the folder button was dragged, show the menu instead.
         if (node && node->is_folder()) {
           views::MenuButton* menu_button =
               static_cast<views::MenuButton*>(sender);
           menu_button->Activate();
           return false;
         }
         break;
       }
     }
   }
   return true;
 }
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
   if (view == other_bookmarked_button_) {
-    node = model_->other_node();
+    node = model()->other_node();
   } else if (view == managed_bookmarks_button_) {
     node = client_->managed_node();
   } else if (view == overflow_button_) {
-    node = model_->bookmark_bar_node();
+    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);
+    node = model()->bookmark_bar_node()->GetChild(button_index);
   }
 
   RecordBookmarkFolderOpen(GetBookmarkLaunchLocation());
   bookmark_menu_ = new BookmarkMenuController(
       browser_, page_navigator_, GetWidget(), node, start_index);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const ui::Event& event) {
   WindowOpenDisposition disposition_from_event_flags =
       ui::DispositionFromEventFlags(event.flags());
 
   if (sender->tag() == kAppsShortcutButtonTag) {
     OpenURLParams params(GURL(chrome::kChromeUIAppsURL),
                          Referrer(),
                          disposition_from_event_flags,
                          content::PAGE_TRANSITION_AUTO_BOOKMARK,
                          false);
     page_navigator_->OpenURL(params);
     RecordBookmarkAppsPageOpen(GetBookmarkLaunchLocation());
     return;
   }
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
-    node = model_->other_node();
+    node = model()->other_node();
   } else if (sender->tag() == kManagedFolderButtonTag) {
     node = client_->managed_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
-    node = model_->bookmark_bar_node()->GetChild(index);
+    node = model()->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
   if (node->is_url()) {
     RecordAppLaunch(browser_->profile(), node->url());
     OpenURLParams params(
         node->url(), Referrer(), disposition_from_event_flags,
         content::PAGE_TRANSITION_AUTO_BOOKMARK, false);
     page_navigator_->OpenURL(params);
   } else {
     chrome::OpenAll(GetWidget()->GetNativeWindow(), page_navigator_, node,
                     disposition_from_event_flags, browser_->profile());
   }
 
   RecordBookmarkLaunch(node, GetBookmarkLaunchLocation());
 }
 
 void BookmarkBarView::ShowContextMenuForView(views::View* source,
                                              const gfx::Point& point,
                                              ui::MenuSourceType source_type) {
-  if (!model_->loaded()) {
+  if (!model()->loaded()) {
     // Don't do anything if the model isn't loaded.
     return;
   }
 
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarked_button_) {
-    parent = model_->other_node();
+    parent = model()->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
     // sure the user can't edit/delete the node in this case.
     nodes.push_back(parent);
   } else if (source == managed_bookmarks_button_) {
     parent = client_->managed_node();
     nodes.push_back(parent);
   } else if (source != this && source != apps_page_shortcut_) {
     // User clicked on one of the bookmark buttons, find which one they
     // clicked on, except for the apps page shortcut, which must behave as if
     // the user clicked on the bookmark bar background.
     int bookmark_button_index = GetIndexOf(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     const BookmarkNode* node =
-        model_->bookmark_bar_node()->GetChild(bookmark_button_index);
+        model()->bookmark_bar_node()->GetChild(bookmark_button_index);
     nodes.push_back(node);
     parent = node->parent();
   } else {
-    parent = model_->bookmark_bar_node();
+    parent = model()->bookmark_bar_node();
     nodes.push_back(parent);
   }
   bool close_on_remove =
-      (parent == model_->other_node()) && (parent->child_count() == 1);
+      (parent == model()->other_node()) && (parent->child_count() == 1);
 
   context_menu_.reset(new BookmarkContextMenu(
       GetWidget(), browser_, browser_->profile(),
       browser_->tab_strip_model()->GetActiveWebContents(),
       parent, nodes, close_on_remove));
   context_menu_->RunMenuAt(point, source_type);
 }
 
 void BookmarkBarView::Init() {
   // Note that at this point we're not in a hierarchy so GetThemeProvider() will
@@ skipping 33 matching lines @@
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
   size_animation_.reset(new gfx::SlideAnimation(this));
 
   client_ = BookmarkModelFactory::GetChromeBookmarkClientForProfile(
       browser_->profile());
-  model_ = client_->model();
-  if (model_) {
-    model_->AddObserver(this);
-    if (model_->loaded())
-      BookmarkModelLoaded(model_, false);
+  if (client_) {

[sky, 2014/06/06 19:49:20]

I'm not sure this ever happens, but I suppose that can be dealt with separately.

[Joao da Silva, 2014/06/06 20:12:18]

BookmarkModelFactory::ServiceIsNULLWhileTesting() return true. I'm guessing this
checks for tests that use a TestingProfile but don't call
TestingProfile::CreateBookmarkModel().

+    model()->AddObserver(this);
+    if (model()->loaded())
+      BookmarkModelLoaded(model(), false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() const {
   // We contain six non-bookmark button views: managed bookmarks,
   // other bookmarks, bookmarks separator, chevrons (for overflow), apps page,
   // and the instruction label.
   return child_count() - 6;
@@ skipping 100 matching lines @@
   // We don't always have a theme provider (ui tests, for example).
   if (GetThemeProvider()) {
     button->SetEnabledColor(GetThemeProvider()->GetColor(
         ThemeProperties::COLOR_BOOKMARK_TEXT));
   }
 
   button->ClearMaxTextSize();
   button->set_context_menu_controller(this);
   button->set_drag_controller(this);
   if (node->is_url()) {
-    const gfx::Image& favicon = model_->GetFavicon(node);
+    const gfx::Image& favicon = model()->GetFavicon(node);
     if (!favicon.IsEmpty())
       button->SetIcon(*favicon.ToImageSkia());
     else
       button->SetIcon(GetDefaultFavicon());
   }
   button->set_max_width(kMaxButtonWidth);
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   UpdateButtonsVisibility();
-  if (parent != model_->bookmark_bar_node()) {
+  if (parent != model->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   const BookmarkNode* node = parent->GetChild(index);
   ProfileSyncService* sync_service(ProfileSyncServiceFactory::
       GetInstance()->GetForProfile(browser_->profile()));
   if (!throbbing_view_ && sync_service && sync_service->FirstSetupInProgress())
     StartThrobbing(node, true);
   AddChildViewAt(CreateBookmarkButton(node), index);
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
   UpdateButtonsVisibility();
 
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
   // the same time as the user reorders.
 
-  if (parent != model_->bookmark_bar_node()) {
+  if (parent != model->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   views::View* button = child_at(index);
   RemoveChildView(button);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               const BookmarkNode* node) {
-  if (node->parent() != model_->bookmark_bar_node()) {
+  if (node->parent() != model->bookmark_bar_node()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
-  int index = model_->bookmark_bar_node()->GetIndexOf(node);
+  int index = model->bookmark_bar_node()->GetIndexOf(node);
   DCHECK_NE(-1, index);
   views::TextButton* button = GetBookmarkButton(index);
   gfx::Size old_pref = button->GetPreferredSize();
   ConfigureButton(node, button);
   gfx::Size new_pref = button->GetPreferredSize();
   if (old_pref.width() != new_pref.width()) {
     Layout();
     SchedulePaint();
   } else if (button->visible()) {
     button->SchedulePaint();
   }
 }
 
 void BookmarkBarView::ShowDropFolderForNode(const BookmarkNode* node) {
   if (bookmark_drop_menu_) {
     if (bookmark_drop_menu_->node() == node) {
       // Already showing for the specified node.
       return;
     }
     bookmark_drop_menu_->Cancel();
   }
 
   views::MenuButton* menu_button = GetMenuButtonForNode(node);
   if (!menu_button)
     return;
 
   int start_index = 0;
-  if (node == model_->bookmark_bar_node())
+  if (node == model()->bookmark_bar_node())
     start_index = GetFirstHiddenNodeIndex();
 
   drop_info_->is_menu_showing = true;
   bookmark_drop_menu_ = new BookmarkMenuController(browser_,
       page_navigator_, GetWidget(), node, start_index);
   bookmark_drop_menu_->set_observer(this);
   bookmark_drop_menu_->RunMenuAt(this, true);
 }
 
 void BookmarkBarView::StopShowFolderDropMenuTimer() {
@@ skipping 12 matching lines @@
       FROM_HERE,
       base::Bind(&BookmarkBarView::ShowDropFolderForNode,
                  show_folder_method_factory_.GetWeakPtr(),
                  node),
       base::TimeDelta::FromMilliseconds(views::GetMenuShowDelay()));
 }
 
 void BookmarkBarView::CalculateDropLocation(const DropTargetEvent& event,
                                             const BookmarkNodeData& data,
                                             DropLocation* location) {
-  DCHECK(model_);
-  DCHECK(model_->loaded());
+  DCHECK(client_);
+  DCHECK(model()->loaded());
   DCHECK(data.is_valid());
 
   *location = DropLocation();
 
   // 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_->visible() && 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;
-    const BookmarkNode* node = data.GetFirstNode(model_, profile->GetPath());
+    const BookmarkNode* node = data.GetFirstNode(model(), profile->GetPath());
     int ops = node && client_->CanBeEditedByUser(node) ?
         ui::DragDropTypes::DRAG_MOVE :
         ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
     location->operation = chrome::GetPreferredBookmarkDropOperation(
         event.source_operations(), ops);
     return;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
        GetBookmarkButton(i)->visible() && !found; i++) {
     views::TextButton* button = GetBookmarkButton(i);
     int button_x = mirrored_x - button->x();
     int button_w = button->width();
     if (button_x < button_w) {
       found = true;
-      const BookmarkNode* node = model_->bookmark_bar_node()->GetChild(i);
+      const BookmarkNode* node = model()->bookmark_bar_node()->GetChild(i);
       if (node->is_folder()) {
         if (button_x <= views::kDropBetweenPixels) {
           location->index = i;
         } else if (button_x < button_w - views::kDropBetweenPixels) {
           location->index = i;
           location->on = true;
         } else {
           location->index = i + 1;
         }
       } else if (button_x < button_w / 2) {
@@ skipping 26 matching lines @@
       // Mouse is after the last visible button but before more recently
       // bookmarked; use the last visible index.
       location->index = GetFirstHiddenNodeIndex();
     } else {
       return;
     }
   }
 
   if (location->on) {
     const BookmarkNode* parent = (location->button_type == DROP_OTHER_FOLDER) ?
-        model_->other_node() :
-        model_->bookmark_bar_node()->GetChild(location->index);
+        model()->other_node() :
+        model()->bookmark_bar_node()->GetChild(location->index);
     location->operation = chrome::GetBookmarkDropOperation(
         profile, event, data, parent, parent->child_count());
     if (!location->operation && !data.has_single_url() &&
-        data.GetFirstNode(model_, profile->GetPath()) == parent) {
+        data.GetFirstNode(model(), profile->GetPath()) == parent) {
       // Don't open a menu if the node being dragged is the menu to open.
       location->on = false;
     }
   } else {
     location->operation = chrome::GetBookmarkDropOperation(
-        profile, event, data, model_->bookmark_bar_node(), location->index);
+        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(browser_->profile()->GetPath(), 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* bbn = model()->bookmark_bar_node();
   const BookmarkNode* parent_on_bb = node;
   while (parent_on_bb) {
     const BookmarkNode* parent = parent_on_bb->parent();
     if (parent == bbn)
       break;
     parent_on_bb = parent;
   }
   if (parent_on_bb) {
     int index = bbn->GetIndexOf(parent_on_bb);
     if (index >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       throbbing_view_ = overflow_button_;
     } else if (!overflow_only) {
       throbbing_view_ = static_cast<CustomButton*>(child_at(index));
     }
   } else if (client_->IsDescendantOfManagedNode(node)) {
     throbbing_view_ = managed_bookmarks_button_;
   } else if (!overflow_only) {
     throbbing_view_ = other_bookmarked_button_;
   }
 
   // Use a large number so that the button continues to throb.
   if (throbbing_view_)
     throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 views::CustomButton* BookmarkBarView::DetermineViewToThrobFromRemove(
     const BookmarkNode* parent,
     int old_index) {
-  const BookmarkNode* bbn = model_->bookmark_bar_node();
+  const BookmarkNode* bbn = model()->bookmark_bar_node();
   const BookmarkNode* old_node = parent;
   int old_index_on_bb = old_index;
   while (old_node && old_node != bbn) {
     const BookmarkNode* parent = old_node->parent();
     if (parent == bbn) {
       old_index_on_bb = bbn->GetIndexOf(old_node);
       break;
     }
     old_node = parent;
   }
@@ skipping 19 matching lines @@
       theme_provider->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetEnabledColor(text_color);
   other_bookmarked_button_->SetEnabledColor(text_color);
   managed_bookmarks_button_->SetEnabledColor(text_color);
   if (apps_page_shortcut_->visible())
     apps_page_shortcut_->SetEnabledColor(text_color);
 }
 
 void BookmarkBarView::UpdateButtonsVisibility() {
-  bool has_other_children = !model_->other_node()->empty();
+  bool has_other_children = !model()->other_node()->empty();
   bool update_other = has_other_children != other_bookmarked_button_->visible();
   if (update_other) {
     other_bookmarked_button_->SetVisible(has_other_children);
     UpdateBookmarksSeparatorVisibility();
   }
 
   bool has_managed_children = !client_->managed_node()->empty();
   bool update_managed =
       has_managed_children != managed_bookmarks_button_->visible();
   if (update_managed)
@@ skipping 63 matching lines @@
   // Then comes the managed bookmarks folder, if visible.
   if (managed_bookmarks_button_->visible()) {
     gfx::Size managed_bookmarks_pref = managed_bookmarks_button_->visible() ?
         managed_bookmarks_button_->GetPreferredSize() : gfx::Size();
     managed_bookmarks_button_->SetBounds(x, y, managed_bookmarks_pref.width(),
                                          height);
     x += managed_bookmarks_pref.width() + kButtonPadding;
   }
 
   // Then go through the bookmark buttons.
-  if (GetBookmarkButtonCount() == 0 && model_ && model_->loaded()) {
+  if (GetBookmarkButtonCount() == 0 && client_ && model()->loaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     instructions_->SetBounds(
         x + kInstructionsPadding, y,
         std::min(static_cast<int>(pref.width()),
                  max_x - x),
         height);
     instructions_->SetVisible(true);
   } else {
     instructions_->SetVisible(false);
 
@@ skipping 42 matching lines @@
   DCHECK(apps_page_shortcut_);
   // Only perform layout if required.
   bool visible = chrome::ShouldShowAppsShortcutInBookmarkBar(
       browser_->profile(), browser_->host_desktop_type());
   if (apps_page_shortcut_->visible() == visible)
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   Layout();
 }