[Android] Change enhanced bookmark top level definitions.

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"
@@ skipping 192 matching lines @@
     }
   }
 }
 
 void BookmarksBridge::GetTopLevelFolderParentIDs(JNIEnv* env,
                                                  jobject obj,
                                                  jobject j_result_obj) {
   Java_BookmarksBridge_addToBookmarkIdList(
       env, j_result_obj, bookmark_model_->root_node()->id(),
       GetBookmarkType(bookmark_model_->root_node()));
-  Java_BookmarksBridge_addToBookmarkIdList(
-      env, j_result_obj, bookmark_model_->mobile_node()->id(),
-      GetBookmarkType(bookmark_model_->mobile_node()));
-  Java_BookmarksBridge_addToBookmarkIdList(
-      env, j_result_obj, bookmark_model_->other_node()->id(),
-      GetBookmarkType(bookmark_model_->other_node()));
 }
 
 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 (partner_bookmarks_shim_->HasPartnerBookmarks()) {
       top_level_folders.push_back(
           partner_bookmarks_shim_->GetPartnerBookmarksRoot());
     }
   }
   std::size_t special_count = top_level_folders.size();
 
   if (get_normal) {
     DCHECK_EQ(bookmark_model_->root_node()->child_count(), 4);
 
-    top_level_folders.push_back(bookmark_model_->bookmark_bar_node());
-
     const BookmarkNode* mobile_node = bookmark_model_->mobile_node();
     for (int i = 0; i < mobile_node->child_count(); ++i) {
       const BookmarkNode* node = mobile_node->GetChild(i);
       if (node->is_folder()) {
         top_level_folders.push_back(node);
       }
     }
 
+    const BookmarkNode* bookmark_bar_node =
+        bookmark_model_->bookmark_bar_node();
+    for (int i = 0; i < bookmark_bar_node->child_count(); ++i) {
+      const BookmarkNode* node = bookmark_bar_node->GetChild(i);
+      if (node->is_folder()) {
+        top_level_folders.push_back(node);
+      }
+    }
+
     const BookmarkNode* other_node = bookmark_model_->other_node();
     for (int i = 0; i < other_node->child_count(); ++i) {
       const BookmarkNode* node = other_node->GetChild(i);
       if (node->is_folder()) {
         top_level_folders.push_back(node);
       }
     }
 
     scoped_ptr<icu::Collator> collator = GetICUCollator();
     std::stable_sort(top_level_folders.begin() + special_count,
                      top_level_folders.end(),
                      BookmarkTitleComparer(this, collator.get()));
   }
 
   for (std::vector<const BookmarkNode*>::const_iterator it =
       top_level_folders.begin(); it != top_level_folders.end(); ++it) {
     Java_BookmarksBridge_addToBookmarkIdList(env,
                                              j_result_obj,
                                              (*it)->id(),
                                              GetBookmarkType(*it));
   }
 }
 
-void BookmarksBridge::GetUncategorizedBookmarkIDs(JNIEnv* env,
-                                                  jobject obj,
-                                                  jobject j_result_obj) {
-  const BookmarkNode* mobile_node = bookmark_model_->mobile_node();
-  for (int i = 0; i < mobile_node->child_count(); ++i) {
-    const BookmarkNode* node = mobile_node->GetChild(i);
-    if (!node->is_folder()) {
-      Java_BookmarksBridge_addToBookmarkIdList(env,
-                                               j_result_obj,
-                                               node->id(),
-                                               GetBookmarkType(node));
-    }
-  }
-
-  const BookmarkNode* other_node = bookmark_model_->other_node();
-  for (int i = 0; i < other_node->child_count(); ++i) {
-    const BookmarkNode* node = other_node->GetChild(i);
-    if (!node->is_folder()) {
-      Java_BookmarksBridge_addToBookmarkIdList(env,
-                                               j_result_obj,
-                                               node->id(),
-                                               GetBookmarkType(node));
-    }
-  }
-}
-
 void BookmarksBridge::GetAllFoldersWithDepths(JNIEnv* env,
                                               jobject obj,
                                               jobject j_folders_obj,
                                               jobject j_depths_obj) {
   DCHECK(IsLoaded());
 
-  const BookmarkNode* desktop = bookmark_model_->bookmark_bar_node();
-  const BookmarkNode* mobile = bookmark_model_->mobile_node();
-  const BookmarkNode* other = bookmark_model_->other_node();
-
   scoped_ptr<icu::Collator> collator = GetICUCollator();
 
   // Vector to temporarily contain all child bookmarks at same level for sorting
   std::vector<const BookmarkNode*> bookmarkList;
+
   // Stack for Depth-First Search of bookmark model. It stores nodes and their
   // heights.
   std::stack<std::pair<const BookmarkNode*, int> > stk;
 
-  for (int i = 0; i < mobile->child_count(); ++i) {
-    const BookmarkNode* child = mobile->GetChild(i);
-    if (child->is_folder() && client_->CanBeEditedByUser(child))
-      bookmarkList.push_back(child);
-  }
-  for (int i = 0; i < other->child_count(); ++i) {
-    const BookmarkNode* child = other->GetChild(i);
-    if (child->is_folder() && client_->CanBeEditedByUser(child))
-      bookmarkList.push_back(child);
-  }
-  bookmarkList.push_back(desktop);
-  std::stable_sort(bookmarkList.begin(),
-                   bookmarkList.end(),
-                   BookmarkTitleComparer(this, collator.get()));
+  bookmarkList.push_back(bookmark_model_->mobile_node());
+  bookmarkList.push_back(bookmark_model_->bookmark_bar_node());
+  bookmarkList.push_back(bookmark_model_->other_node());
 
   // Push all sorted top folders in stack and give them depth of 0.
   // Note the order to push folders to stack should be opposite to the order in
   // output.
   for (std::vector<const BookmarkNode*>::reverse_iterator it =
            bookmarkList.rbegin();
        it != bookmarkList.rend();
        ++it) {
     stk.push(std::make_pair(*it, 0));
   }
@@ skipping 705 matching lines @@
   BookmarkModelChanged();
 }
 
 void BookmarksBridge::PartnerShimLoaded(PartnerBookmarksShim* shim) {
   NotifyIfDoneLoading();
 }
 
 void BookmarksBridge::ShimBeingDeleted(PartnerBookmarksShim* shim) {
   partner_bookmarks_shim_ = NULL;
 }