Fix componentization of chrome/browser/bookmarks

chrome/browser/android/provider/chrome_browser_provider.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/android/provider/chrome_browser_provider.h"
 
 #include <cmath>
 #include <list>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/provider/blocking_ui_thread_async_request.h"
 #include "chrome/browser/android/provider/bookmark_model_observer_task.h"
 #include "chrome/browser/android/provider/run_on_ui_thread_blocking.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/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/android/sqlite_cursor.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/top_sites_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service_factory.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/favicon/core/favicon_service.h"
 #include "components/history/core/browser/android/android_history_types.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/ChromeBrowserProvider_jni.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/favicon_size.h"
 
 using base::android::AttachCurrentThread;
 using base::android::CheckException;
 using base::android::ClearException;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::GetClass;
 using base::android::MethodID;
 using base::android::JavaRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
+using bookmarks::ManagedBookmarkService;
 using content::BrowserThread;
 
 // After refactoring the following class hierarchy has been created in order
 // to avoid repeating code again for the same basic kind of tasks, to enforce
 // the correct thread usage and to prevent known race conditions and deadlocks.
 //
 // - RunOnUIThreadBlocking: auxiliary class to run methods in the UI thread
 //   blocking the current one until finished. Because of the provider threading
 //   expectations this cannot be used from the UI thread.
 //
@@ skipping 402 matching lines @@
                                    parent->id(), result);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CreateBookmarksFolderOnceTask);
 };
 
 // Creates a Java BookmarkNode object for a node given its id.
 class GetEditableBookmarkFoldersTask : public BookmarkModelTask {
  public:
-  GetEditableBookmarkFoldersTask(ChromeBookmarkClient* client,
-                                 BookmarkModel* model)
-      : BookmarkModelTask(model), client_(client) {}
+  GetEditableBookmarkFoldersTask(
+      ManagedBookmarkService* managed_bookmark_service,
+      BookmarkModel* model)
+      : BookmarkModelTask(model),
+        managed_bookmark_service_(managed_bookmark_service) {}
 
   void Run(ScopedJavaGlobalRef<jobject>* jroot) {
     RunOnUIThreadBlocking::Run(
         base::Bind(&GetEditableBookmarkFoldersTask::RunOnUIThread,
-                   client_, model(), jroot));
+                   managed_bookmark_service_, model(), jroot));
   }
 
-  static void RunOnUIThread(ChromeBookmarkClient* client,
+  static void RunOnUIThread(ManagedBookmarkService* managed,
                             BookmarkModel* model,
                             ScopedJavaGlobalRef<jobject>* jroot) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* root = model->root_node();
     if (!root || !root->is_folder())
       return;
 
     // The iterative approach is not possible because ScopedGlobalJavaRefs
     // cannot be copy-constructed, and therefore not used in STL containers.
-    ConvertFolderSubtree(client, AttachCurrentThread(), root,
+    ConvertFolderSubtree(managed, AttachCurrentThread(), root,
                          ScopedJavaLocalRef<jobject>(), jroot);
   }
 
  private:
-  static void ConvertFolderSubtree(ChromeBookmarkClient* client,
+  static void ConvertFolderSubtree(ManagedBookmarkService* managed,
                                    JNIEnv* env,
                                    const BookmarkNode* node,
                                    const JavaRef<jobject>& parent_folder,
                                    ScopedJavaGlobalRef<jobject>* jfolder) {
     DCHECK(node);
     DCHECK(node->is_folder());
     DCHECK(jfolder);
 
     // Global refs should be used here for thread-safety reasons as this task
     // might be invoked from a thread other than UI. All refs are scoped.
     ConvertBookmarkNode(node, parent_folder, jfolder);
 
     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->CanBeEditedByUser(child)) {
         ScopedJavaGlobalRef<jobject> jchild;
-        ConvertFolderSubtree(client, env, child, *jfolder, &jchild);
+        ConvertFolderSubtree(managed, env, child, *jfolder, &jchild);
 
         Java_BookmarkNode_addChild(env, jfolder->obj(), jchild.obj());
         if (ClearException(env)) {
           LOG(WARNING) << "Java exception while adding child node.";
           return;
         }
       }
     }
   }
 
-  ChromeBookmarkClient* client_;
+  ManagedBookmarkService* managed_bookmark_service_;
 
   DISALLOW_COPY_AND_ASSIGN(GetEditableBookmarkFoldersTask);
 };
 
 // Creates a Java BookmarkNode object for a node given its id.
 class GetBookmarkNodeTask : public BookmarkModelTask {
  public:
   explicit GetBookmarkNodeTask(BookmarkModel* model)
       : BookmarkModelTask(model) {
   }
@@ skipping 950 matching lines @@
     return kInvalidBookmarkId;
 
   CreateBookmarksFolderOnceTask task(bookmark_model_);
   return task.Run(title, parent_id);
 }
 
 ScopedJavaLocalRef<jobject> ChromeBrowserProvider::GetEditableBookmarkFolders(
     JNIEnv* env,
     jobject obj) {
   ScopedJavaGlobalRef<jobject> jroot;
-  ChromeBookmarkClient* client =
-      ChromeBookmarkClientFactory::GetForProfile(profile_);
+  ManagedBookmarkService* managed =
+      ManagedBookmarkServiceFactory::GetForProfile(profile_);
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
-  GetEditableBookmarkFoldersTask task(client, model);
+  GetEditableBookmarkFoldersTask task(managed, model);
   task.Run(&jroot);
   return ScopedJavaLocalRef<jobject>(jroot);
 }
 
 void ChromeBrowserProvider::RemoveAllUserBookmarks(JNIEnv* env, jobject obj) {
   LOG(ERROR) << "begin ChromeBrowserProvider::RemoveAllUserBookmarks";
   RemoveAllUserBookmarksTask task(bookmark_model_);
   task.Run();
   LOG(ERROR) << "end ChromeBrowserProvider::RemoveAllUserBookmarks";
 }
@@ skipping 120 matching lines @@
   ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
   if (obj.is_null())
     return;
   Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
 }
 
 void ChromeBrowserProvider::OnKeywordSearchTermDeleted(
     history::HistoryService* history_service,
     history::URLID url_id) {
 }