[Android] EnhancedBookmarksBridge for bookmark description read&write.

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_string.h"
 #include "base/containers/stack_container.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/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
+#include "components/bookmarks/common/android/bookmark_type.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/BookmarksBridge_jni.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ScopedJavaLocalRef;
 using base::android::ScopedJavaGlobalRef;
+using bookmarks::android::JavaBookmarkIdGetId;
+using bookmarks::android::JavaBookmarkIdGetType;
+using bookmarks::BookmarkType;
 using content::BrowserThread;
 
-// Should mirror constants in BookmarksBridge.java
-static const int kBookmarkTypeNormal = 0;
-static const int kBookmarkTypePartner = 1;
+namespace {
 
-namespace {
 class BookmarkNodeCreationTimeCompareFunctor {
  public:
   bool operator()(const BookmarkNode* lhs, const BookmarkNode* rhs) {
     return lhs->date_added().ToJavaTime() > rhs->date_added().ToJavaTime();
   }
 };
 }  // namespace
 
 BookmarksBridge::BookmarksBridge(JNIEnv* env,
                                  jobject obj,
@@ skipping 37 matching lines @@
 // static
 bool BookmarksBridge::RegisterBookmarksBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jlong Init(JNIEnv* env, jobject obj, jobject j_profile) {
   BookmarksBridge* delegate = new BookmarksBridge(env, obj, j_profile);
   return reinterpret_cast<intptr_t>(delegate);
 }
 
+static jlong GetNativeBookmarkModel(JNIEnv* env,
+                                    jclass caller,
+                                    jobject j_profile) {
+  Profile *profile = ProfileAndroid::FromProfileAndroid(j_profile);
+  BookmarkModel *bookmark_model_ = BookmarkModelFactory::GetForProfile(profile);
+  return reinterpret_cast<jlong>(bookmark_model_);
+}
+
 static bool IsEditBookmarksEnabled() {
   return ProfileManager::GetLastUsedProfile()->GetPrefs()->GetBoolean(
       prefs::kEditBookmarksEnabled);
 }
 
 static jboolean IsEditBookmarksEnabled(JNIEnv* env, jclass clazz) {
   return IsEditBookmarksEnabled();
 }
 
 ScopedJavaLocalRef<jobject> BookmarksBridge::GetBookmarkByID(JNIEnv* env,
@@ skipping 59 matching lines @@
   }
 
   // Partner bookmark root node is under mobile node.
   if (parent == bookmark_model_->mobile_node() && get_folders &&
       partner_bookmarks_shim_->HasPartnerBookmarks() &&
       IsReachable(partner_bookmarks_shim_->GetPartnerBookmarksRoot())) {
     Java_BookmarksBridge_addToBookmarkIdList(
         env,
         j_result_obj,
         partner_bookmarks_shim_->GetPartnerBookmarksRoot()->id(),
-        kBookmarkTypePartner);
+        BookmarkType::PARTNER);
   }
 }
 
 void BookmarksBridge::GetAllBookmarkIDsOrderedByCreationDate(
     JNIEnv* env,
     jobject obj,
     jobject j_result_obj) {
   DCHECK(IsLoaded());
   std::list<const BookmarkNode*> folders;
   std::vector<const BookmarkNode*> result;
@@ skipping 68 matching lines @@
   DCHECK(IsLoaded());
   return GetNodeByID(id, type);
 }
 
 void BookmarksBridge::GetBookmarksForFolder(JNIEnv* env,
                                             jobject obj,
                                             jobject j_folder_id_obj,
                                             jobject j_callback_obj,
                                             jobject j_result_obj) {
   DCHECK(IsLoaded());
-  long folder_id = Java_BookmarkId_getId(env, j_folder_id_obj);
-  int type = Java_BookmarkId_getType(env, j_folder_id_obj);
+  long folder_id = JavaBookmarkIdGetId(env, j_folder_id_obj);
+  int type = JavaBookmarkIdGetType(env, j_folder_id_obj);
   const BookmarkNode* folder = GetFolderWithFallback(folder_id, type);
 
   if (!folder->is_folder() || !IsReachable(folder))
     return;
 
   // Recreate the java bookmarkId object due to fallback.
   ScopedJavaLocalRef<jobject> folder_id_obj =
       Java_BookmarksBridge_createBookmarkId(
           env, folder->id(), GetBookmarkType(folder));
   j_folder_id_obj = folder_id_obj.obj();
@@ skipping 18 matching lines @@
         env, j_callback_obj, j_folder_id_obj, j_result_obj);
   }
 }
 
 void BookmarksBridge::GetCurrentFolderHierarchy(JNIEnv* env,
                                                 jobject obj,
                                                 jobject j_folder_id_obj,
                                                 jobject j_callback_obj,
                                                 jobject j_result_obj) {
   DCHECK(IsLoaded());
-  long folder_id = Java_BookmarkId_getId(env, j_folder_id_obj);
-  int type = Java_BookmarkId_getType(env, j_folder_id_obj);
+  long folder_id = JavaBookmarkIdGetId(env, j_folder_id_obj);
+  int type = JavaBookmarkIdGetType(env, j_folder_id_obj);
   const BookmarkNode* folder = GetFolderWithFallback(folder_id, type);
 
   if (!folder->is_folder() || !IsReachable(folder))
     return;
 
   // Recreate the java bookmarkId object due to fallback.
   ScopedJavaLocalRef<jobject> folder_id_obj =
       Java_BookmarksBridge_createBookmarkId(
           env, folder->id(), GetBookmarkType(folder));
   j_folder_id_obj = folder_id_obj.obj();
 
   // Get the folder hierarchy.
   const BookmarkNode* node = folder;
   while (node) {
     ExtractBookmarkNodeInformation(node, j_result_obj);
     node = GetParentNode(node);
   }
 
   Java_BookmarksCallback_onBookmarksFolderHierarchyAvailable(
       env, j_callback_obj, j_folder_id_obj, j_result_obj);
 }
 
 void BookmarksBridge::DeleteBookmark(JNIEnv* env,
                                      jobject obj,
                                      jobject j_bookmark_id_obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(IsLoaded());
 
-  long bookmark_id = Java_BookmarkId_getId(env, j_bookmark_id_obj);
-  int type = Java_BookmarkId_getType(env, j_bookmark_id_obj);
+  long bookmark_id = JavaBookmarkIdGetId(env, j_bookmark_id_obj);
+  int type = JavaBookmarkIdGetType(env, j_bookmark_id_obj);
   const BookmarkNode* node = GetNodeByID(bookmark_id, type);
   if (!IsEditable(node)) {
     NOTREACHED();
     return;
   }
 
   if (partner_bookmarks_shim_->IsPartnerBookmark(node)) {
     partner_bookmarks_shim_->RemoveBookmark(node);
   } else {
     const BookmarkNode* parent_node = GetParentNode(node);
     bookmark_model_->Remove(parent_node, parent_node->GetIndexOf(node));
   }
 }
 
 void BookmarksBridge::MoveBookmark(JNIEnv* env,
                                    jobject obj,
                                    jobject j_bookmark_id_obj,
                                    jobject j_parent_id_obj,
                                    jint index) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(IsLoaded());
 
-  long bookmark_id = Java_BookmarkId_getId(env, j_bookmark_id_obj);
-  int type = Java_BookmarkId_getType(env, j_bookmark_id_obj);
+  long bookmark_id = JavaBookmarkIdGetId(env, j_bookmark_id_obj);
+  int type = JavaBookmarkIdGetType(env, j_bookmark_id_obj);
   const BookmarkNode* node = GetNodeByID(bookmark_id, type);
   if (!IsEditable(node)) {
     NOTREACHED();
     return;
   }
-  bookmark_id = Java_BookmarkId_getId(env, j_parent_id_obj);
-  type = Java_BookmarkId_getType(env, j_parent_id_obj);
+  bookmark_id = JavaBookmarkIdGetId(env, j_parent_id_obj);
+  type = JavaBookmarkIdGetType(env, j_parent_id_obj);
   const BookmarkNode* new_parent_node = GetNodeByID(bookmark_id, type);
   bookmark_model_->Move(node, new_parent_node, index);
 }
 
 ScopedJavaLocalRef<jobject> BookmarksBridge::CreateJavaBookmark(
     const BookmarkNode* node) {
   JNIEnv* env = AttachCurrentThread();
 
   const BookmarkNode* parent = GetParentNode(node);
   int64 parent_id = parent ? parent->id() : -1;
@@ skipping 19 matching lines @@
                                                      jobject j_result_obj) {
   JNIEnv* env = AttachCurrentThread();
   if (!IsReachable(node))
     return;
   Java_BookmarksBridge_addToList(
       env, j_result_obj, CreateJavaBookmark(node).obj());
 }
 
 const BookmarkNode* BookmarksBridge::GetNodeByID(long node_id, int type) {
   const BookmarkNode* node;
-  if (type == kBookmarkTypePartner) {
+  if (type == BookmarkType::PARTNER) {
     node = partner_bookmarks_shim_->GetNodeByID(
         static_cast<int64>(node_id));
   } else {
     node = bookmarks::GetBookmarkNodeByID(bookmark_model_,
                                           static_cast<int64>(node_id));
   }
   return node;
 }
 
 const BookmarkNode* BookmarksBridge::GetFolderWithFallback(long folder_id,
@@ skipping 29 matching lines @@
   DCHECK(IsLoaded());
   if (node == partner_bookmarks_shim_->GetPartnerBookmarksRoot()) {
     return bookmark_model_->mobile_node();
   } else {
     return node->parent();
   }
 }
 
 int BookmarksBridge::GetBookmarkType(const BookmarkNode* node) {
   if (partner_bookmarks_shim_->IsPartnerBookmark(node))
-    return kBookmarkTypePartner;
+    return BookmarkType::PARTNER;
   else
-    return kBookmarkTypeNormal;
+    return BookmarkType::NORMAL;
 }
 
 base::string16 BookmarksBridge::GetTitle(const BookmarkNode* node) const {
   if (partner_bookmarks_shim_->IsPartnerBookmark(node))
     return partner_bookmarks_shim_->GetTitle(node);
   return node->GetTitle();
 }
 
 bool BookmarksBridge::IsReachable(const BookmarkNode* node) const {
   if (!partner_bookmarks_shim_->IsPartnerBookmark(node))
@@ skipping 177 matching lines @@
   BookmarkModelChanged();
 }
 
 void BookmarksBridge::PartnerShimLoaded(PartnerBookmarksShim* shim) {
   NotifyIfDoneLoading();
 }
 
 void BookmarksBridge::ShimBeingDeleted(PartnerBookmarksShim* shim) {
   partner_bookmarks_shim_ = NULL;
 }