Fix componentization of chrome/browser/bookmarks

chrome/browser/android/bookmarks/bookmarks_bridge.cc

 // Copyright 2013 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/android/bookmarks/bookmarks_bridge.h"
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/containers/stack_container.h"
 #include "base/i18n/string_compare.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
 #include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
+#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
 #include "components/bookmarks/common/android/bookmark_type.h"
+#include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/query_parser/query_parser.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/undo/bookmark_undo_service.h"
 #include "components/undo/undo_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/components_strings.h"
 #include "jni/BookmarksBridge_jni.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 52 matching lines @@
   return collator_.Pass();
 }
 
 }  // namespace
 
 BookmarksBridge::BookmarksBridge(JNIEnv* env,
                                  jobject obj,
                                  jobject j_profile)
     : weak_java_ref_(env, obj),
       bookmark_model_(NULL),
-      client_(NULL),
+      managed_bookmark_service_(NULL),
       partner_bookmarks_shim_(NULL) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   profile_ = ProfileAndroid::FromProfileAndroid(j_profile);
   bookmark_model_ = BookmarkModelFactory::GetForProfile(profile_);
-  client_ = ChromeBookmarkClientFactory::GetForProfile(profile_);
+  managed_bookmark_service_ =
+      ManagedBookmarkServiceFactory::GetForProfile(profile_);
 
   // Registers the notifications we are interested.
   bookmark_model_->AddObserver(this);
 
   // Create the partner Bookmarks shim as early as possible (but don't attach).
   partner_bookmarks_shim_ = PartnerBookmarksShim::BuildForBrowserContext(
       chrome::GetBrowserContextRedirectedInIncognito(profile_));
   partner_bookmarks_shim_->AddObserver(this);
 
   NotifyIfDoneLoading();
@@ skipping 103 matching lines @@
 
 void BookmarksBridge::GetTopLevelFolderIDs(JNIEnv* env,
                                            jobject obj,
                                            jboolean get_special,
                                            jboolean get_normal,
                                            jobject j_result_obj) {
   DCHECK(IsLoaded());
   std::vector<const BookmarkNode*> top_level_folders;
 
   if (get_special) {
-    if (client_->managed_node() &&
-        client_->managed_node()->child_count() > 0) {
-      top_level_folders.push_back(client_->managed_node());
+    if (managed_bookmark_service_->managed_node() &&
+        managed_bookmark_service_->managed_node()->child_count() > 0) {
+      top_level_folders.push_back(managed_bookmark_service_->managed_node());
     }
-    if (client_->supervised_node() &&
-        client_->supervised_node()->child_count() > 0) {
-      top_level_folders.push_back(client_->supervised_node());
+    if (managed_bookmark_service_->supervised_node() &&
+        managed_bookmark_service_->supervised_node()->child_count() > 0) {
+      top_level_folders.push_back(managed_bookmark_service_->supervised_node());
     }
     if (partner_bookmarks_shim_->HasPartnerBookmarks()
         && IsReachable(partner_bookmarks_shim_->GetPartnerBookmarksRoot())) {
       top_level_folders.push_back(
           partner_bookmarks_shim_->GetPartnerBookmarksRoot());
     }
   }
   std::size_t special_count = top_level_folders.size();
 
   if (get_normal) {
@@ skipping 74 matching lines @@
     stk.pop();
     Java_BookmarksBridge_addToBookmarkIdListWithDepth(env,
                                                       j_folders_obj,
                                                       node->id(),
                                                       GetBookmarkType(node),
                                                       j_depths_obj,
                                                       depth);
     bookmarkList.clear();
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child = node->GetChild(i);
-      if (child->is_folder() && client_->CanBeEditedByUser(child))
+      if (child->is_folder() &&
+          managed_bookmark_service_->CanBeEditedByUser(child)) {
         bookmarkList.push_back(node->GetChild(i));
+      }
     }
     std::stable_sort(bookmarkList.begin(),
                      bookmarkList.end(),
                      BookmarkTitleComparer(this, collator.get()));
     for (std::vector<const BookmarkNode*>::reverse_iterator it =
              bookmarkList.rbegin();
          it != bookmarkList.rend();
          ++it) {
       stk.push(std::make_pair(*it, depth + 1));
     }
@@ skipping 101 matching lines @@
       folder_iter != folders.end(); ++folder_iter) {
     if (*folder_iter == NULL)
       continue;
 
     std::list<const BookmarkNode*>::iterator insert_iter = folder_iter;
     ++insert_iter;
 
     for (int i = 0; i < (*folder_iter)->child_count(); ++i) {
       const BookmarkNode* child = (*folder_iter)->GetChild(i);
       if (!IsReachable(child) ||
-          bookmarks::IsDescendantOf(child, client_->managed_node()) ||
-          bookmarks::IsDescendantOf(child, client_->supervised_node())) {
+          bookmarks::IsDescendantOf(
+              child, managed_bookmark_service_->managed_node()) ||
+          bookmarks::IsDescendantOf(
+              child, managed_bookmark_service_->supervised_node())) {
         continue;
       }
 
       if (child->is_folder()) {
         insert_iter = folders.insert(insert_iter, child);
       } else {
         result.push_back(child);
       }
     }
   }
@@ skipping 300 matching lines @@
                                           static_cast<int64>(node_id));
   }
   return node;
 }
 
 const BookmarkNode* BookmarksBridge::GetFolderWithFallback(long folder_id,
                                                            int type) {
   const BookmarkNode* folder = GetNodeByID(folder_id, type);
   if (!folder || folder->type() == BookmarkNode::URL ||
       !IsFolderAvailable(folder)) {
-    if (!client_->managed_node()->empty())
-      folder = client_->managed_node();
+    if (!managed_bookmark_service_->managed_node()->empty())
+      folder = managed_bookmark_service_->managed_node();
     else
       folder = bookmark_model_->mobile_node();
   }
   return folder;
 }
 
 bool BookmarksBridge::IsEditable(const BookmarkNode* node) const {
   if (!node || (node->type() != BookmarkNode::FOLDER &&
       node->type() != BookmarkNode::URL)) {
     return false;
   }
   if (!IsEditBookmarksEnabled(profile_))
     return false;
   if (partner_bookmarks_shim_->IsPartnerBookmark(node))
     return partner_bookmarks_shim_->IsEditable(node);
-  return client_->CanBeEditedByUser(node);
+  return managed_bookmark_service_->CanBeEditedByUser(node);
 }
 
 bool BookmarksBridge::IsManaged(const BookmarkNode* node) const {
-  return bookmarks::IsDescendantOf(node, client_->managed_node());
+  return bookmarks::IsDescendantOf(node,
+                                   managed_bookmark_service_->managed_node());
 }
 
 const BookmarkNode* BookmarksBridge::GetParentNode(const BookmarkNode* node) {
   DCHECK(IsLoaded());
   if (node == partner_bookmarks_shim_->GetPartnerBookmarksRoot()) {
     return bookmark_model_->mobile_node();
   } else {
     return node->parent();
   }
 }
@@ skipping 12 matching lines @@
 }
 
 bool BookmarksBridge::IsLoaded() const {
   return (bookmark_model_->loaded() && partner_bookmarks_shim_->IsLoaded());
 }
 
 bool BookmarksBridge::IsFolderAvailable(
     const BookmarkNode* folder) const {
   // The managed bookmarks folder is not shown if there are no bookmarks
   // configured via policy.
-  if (folder == client_->managed_node() && folder->empty())
+  if (folder == managed_bookmark_service_->managed_node() && folder->empty())
     return false;
   // Similarly, the supervised bookmarks folder is not shown if there are no
   // bookmarks configured by the custodian.
-  if (folder == client_->supervised_node() && folder->empty())
+  if (folder == managed_bookmark_service_->supervised_node() && folder->empty())
     return false;
 
   SigninManager* signin = SigninManagerFactory::GetForProfile(
       profile_->GetOriginalProfile());
   return (folder->type() != BookmarkNode::BOOKMARK_BAR &&
       folder->type() != BookmarkNode::OTHER_NODE) ||
       (signin && signin->IsAuthenticated());
 }
 
 void BookmarksBridge::NotifyIfDoneLoading() {
@@ skipping 167 matching lines @@
   BookmarkModelChanged();
 }
 
 void BookmarksBridge::PartnerShimLoaded(PartnerBookmarksShim* shim) {
   NotifyIfDoneLoading();
 }
 
 void BookmarksBridge::ShimBeingDeleted(PartnerBookmarksShim* shim) {
   partner_bookmarks_shim_ = NULL;
 }