Fix componentization of chrome/browser/bookmarks

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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
+#include "chrome/browser/bookmarks/managed_bookmark_service_factory.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 14 matching lines @@
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
+#include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/metrics/metrics_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
@@ skipping 428 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ButtonSeparatorView);
 };
 
 // BookmarkBarView ------------------------------------------------------------
 
 // static
 const char BookmarkBarView::kViewClassName[] = "BookmarkBarView";
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
-      client_(NULL),
+      managed_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarks_button_(NULL),
       managed_bookmarks_button_(NULL),
       supervised_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
@@ skipping 83 matching lines @@
   *model_start_index = 0;
 
   if (loc.x() < 0 || loc.x() >= width() || loc.y() < 0 || loc.y() >= height())
     return NULL;
 
   gfx::Point adjusted_loc(GetMirroredXInView(loc.x()), loc.y());
 
   // Check the managed button first.
   if (managed_bookmarks_button_->visible() &&
       managed_bookmarks_button_->bounds().Contains(adjusted_loc)) {
-    return client_->managed_node();
+    return managed_->managed_node();
   }
 
   // Then check the supervised button.
   if (supervised_bookmarks_button_->visible() &&
       supervised_bookmarks_button_->bounds().Contains(adjusted_loc)) {
-    return client_->supervised_node();
+    return managed_->supervised_node();
   }
 
   // Then check the bookmark buttons.
   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);
   }
 
   // Then the overflow button.
   if (overflow_button_->visible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *model_start_index = GetFirstHiddenNodeIndex();
     return model_->bookmark_bar_node();
   }
 
   // And finally the other folder.
   if (other_bookmarks_button_->visible() &&
       other_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return model_->other_node();
   }
 
   return NULL;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
-  if (node == client_->managed_node())
+  if (node == managed_->managed_node())
     return managed_bookmarks_button_;
-  if (node == client_->supervised_node())
+  if (node == managed_->supervised_node())
     return supervised_bookmarks_button_;
   if (node == model_->other_node())
     return other_bookmarks_button_;
   if (node == model_->bookmark_bar_node())
     return overflow_button_;
   int index = model_->bookmark_bar_node()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
     return NULL;
   return static_cast<views::MenuButton*>(child_at(index));
 }
@@ skipping 568 matching lines @@
 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.
   // The actual bookmark buttons are added from Layout().
   DCHECK_EQ(0, GetBookmarkButtonCount());
   DCHECK(model->other_node());
   other_bookmarks_button_->SetAccessibleName(model->other_node()->GetTitle());
   other_bookmarks_button_->SetText(model->other_node()->GetTitle());
   managed_bookmarks_button_->SetAccessibleName(
-      client_->managed_node()->GetTitle());
-  managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
+      managed_->managed_node()->GetTitle());
+  managed_bookmarks_button_->SetText(managed_->managed_node()->GetTitle());
   supervised_bookmarks_button_->SetAccessibleName(
-      client_->supervised_node()->GetTitle());
-  supervised_bookmarks_button_->SetText(client_->supervised_node()->GetTitle());
+      managed_->supervised_node()->GetTitle());
+  supervised_bookmarks_button_->SetText(
+      managed_->supervised_node()->GetTitle());
   UpdateColors();
   UpdateOtherAndManagedButtonsVisibility();
   other_bookmarks_button_->SetEnabled(true);
   managed_bookmarks_button_->SetEnabled(true);
   supervised_bookmarks_button_->SetEnabled(true);
   LayoutAndPaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
@@ skipping 158 matching lines @@
 }
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
   if (view == other_bookmarks_button_) {
     node = model_->other_node();
   } else if (view == managed_bookmarks_button_) {
-    node = client_->managed_node();
+    node = managed_->managed_node();
   } else if (view == supervised_bookmarks_button_) {
-    node = client_->supervised_node();
+    node = managed_->supervised_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);
   }
 
   RecordBookmarkFolderOpen(GetBookmarkLaunchLocation());
@@ skipping 16 matching lines @@
                          false);
     page_navigator_->OpenURL(params);
     RecordBookmarkAppsPageOpen(GetBookmarkLaunchLocation());
     return;
   }
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else if (sender->tag() == kManagedFolderButtonTag) {
-    node = client_->managed_node();
+    node = managed_->managed_node();
   } else if (sender->tag() == kSupervisedFolderButtonTag) {
-    node = client_->supervised_node();
+    node = managed_->supervised_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
   if (node->is_url()) {
     RecordAppLaunch(browser_->profile(), node->url());
     OpenURLParams params(
@@ skipping 17 matching lines @@
   }
 
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarks_button_) {
     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();
+    parent = managed_->managed_node();
     nodes.push_back(parent);
   } else if (source == supervised_bookmarks_button_) {
-    parent = client_->supervised_node();
+    parent = managed_->supervised_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);
@@ skipping 59 matching lines @@
   UpdateBookmarksSeparatorVisibility();
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
   size_animation_.reset(new gfx::SlideAnimation(this));
 
   model_ = BookmarkModelFactory::GetForProfile(browser_->profile());
-  client_ = ChromeBookmarkClientFactory::GetForProfile(browser_->profile());
+  managed_ = ManagedBookmarkServiceFactory::GetForProfile(browser_->profile());
   if (model_) {
     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 {
@@ skipping 165 matching lines @@
   }
   if (index >= GetBookmarkButtonCount())
     return needs_layout;
 
   delete child_at(index);
   return true;
 }
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               const BookmarkNode* node) {
-  if (node == client_->managed_node()) {
+  if (node == managed_->managed_node()) {
     // The managed node may have its title updated.
     managed_bookmarks_button_->SetAccessibleName(
-        client_->managed_node()->GetTitle());
-    managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
+        managed_->managed_node()->GetTitle());
+    managed_bookmarks_button_->SetText(managed_->managed_node()->GetTitle());
     return;
   }
-  if (node == client_->supervised_node()) {
+  if (node == managed_->supervised_node()) {
     // The supervised node may have its title updated.
     supervised_bookmarks_button_->SetAccessibleName(
-        client_->supervised_node()->GetTitle());
+        managed_->supervised_node()->GetTitle());
     supervised_bookmarks_button_->SetText(
-        client_->supervised_node()->GetTitle());
+        managed_->supervised_node()->GetTitle());
     return;
   }
 
   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);
   DCHECK_NE(-1, index);
   if (index >= GetBookmarkButtonCount())
@@ skipping 69 matching lines @@
   if (other_bookmarks_button_->visible() && other_delta_x >= 0 &&
       other_delta_x < other_bookmarks_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());
-    int ops = node && client_->CanBeEditedByUser(node) ?
+    int ops = node && managed_->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::LabelButton* button = GetBookmarkButton(i);
@@ skipping 85 matching lines @@
     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 (bookmarks::IsDescendantOf(node, client_->managed_node())) {
+  } else if (bookmarks::IsDescendantOf(node, managed_->managed_node())) {
     throbbing_view_ = managed_bookmarks_button_;
-  } else if (bookmarks::IsDescendantOf(node, client_->supervised_node())) {
+  } else if (bookmarks::IsDescendantOf(node, managed_->supervised_node())) {
     throbbing_view_ = supervised_bookmarks_button_;
   } else if (!overflow_only) {
     throbbing_view_ = other_bookmarks_button_;
   }
 
   // Use a large number so that the button continues to throb.
   if (throbbing_view_)
     throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
@@ skipping 11 matching lines @@
     }
     old_node = parent;
   }
   if (old_node) {
     if (old_index_on_bb >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       return overflow_button_;
     }
     return static_cast<CustomButton*>(child_at(old_index_on_bb));
   }
-  if (bookmarks::IsDescendantOf(parent, client_->managed_node()))
+  if (bookmarks::IsDescendantOf(parent, managed_->managed_node()))
     return managed_bookmarks_button_;
-  if (bookmarks::IsDescendantOf(parent, client_->supervised_node()))
+  if (bookmarks::IsDescendantOf(parent, managed_->supervised_node()))
     return supervised_bookmarks_button_;
   // Node wasn't on the bookmark bar, use the "Other Bookmarks" button.
   return other_bookmarks_button_;
 }
 
 void BookmarkBarView::UpdateColors() {
   // We don't always have a theme provider (ui tests, for example).
   const ui::ThemeProvider* theme_provider = GetThemeProvider();
   if (!theme_provider)
     return;
@@ skipping 10 matching lines @@
 }
 
 bool BookmarkBarView::UpdateOtherAndManagedButtonsVisibility() {
   bool has_other_children = !model_->other_node()->empty();
   bool update_other = has_other_children != other_bookmarks_button_->visible();
   if (update_other) {
     other_bookmarks_button_->SetVisible(has_other_children);
     UpdateBookmarksSeparatorVisibility();
   }
 
-  bool show_managed = !client_->managed_node()->empty() &&
+  bool show_managed = !managed_->managed_node()->empty() &&
                       browser_->profile()->GetPrefs()->GetBoolean(
                           bookmarks::prefs::kShowManagedBookmarksInBookmarkBar);
   bool update_managed = show_managed != managed_bookmarks_button_->visible();
   if (update_managed)
     managed_bookmarks_button_->SetVisible(show_managed);
 
-  bool show_supervised = !client_->supervised_node()->empty();
+  bool show_supervised = !managed_->supervised_node()->empty();
   bool update_supervised =
       show_supervised != supervised_bookmarks_button_->visible();
   if (update_supervised)
     supervised_bookmarks_button_->SetVisible(show_supervised);
 
   return update_other || update_managed || update_supervised;
 }
 
 void BookmarkBarView::UpdateBookmarksSeparatorVisibility() {
   // Ash does not paint the bookmarks separator line because it looks odd on
@@ skipping 12 matching lines @@
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   LayoutAndPaint();
 }
 
 void BookmarkBarView::OnShowManagedBookmarksPrefChanged() {
   if (UpdateOtherAndManagedButtonsVisibility())
     LayoutAndPaint();
 }