Makes views show the 'mobile' bookmark folder where appropriate.

chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc

 // Copyright (c) 2011 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_menu_delegate.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
@@ skipping 51 matching lines @@
   real_delegate_ = real_delegate;
   if (parent) {
     parent_menu_item_ = parent;
     int initial_count = parent->GetSubmenu() ?
         parent->GetSubmenu()->GetMenuItemCount() : 0;
     if ((start_child_index < node->child_count()) &&
         (initial_count > 0)) {
       parent->AppendSeparator();
     }
     BuildMenu(node, start_child_index, parent, &next_menu_id_);
-    if (show_options == SHOW_OTHER_FOLDER) {
-      const BookmarkNode* other_folder =
-          profile_->GetBookmarkModel()->other_node();
-      if (!other_folder->empty()) {
-        parent->AppendSeparator();
-        BuildOtherFolderMenu(parent, &next_menu_id_);
-      }
-    }
+    if (show_options == SHOW_PERMANENT_FOLDERS)
+      BuildMenusForPermanentNodes(parent, &next_menu_id_);
   } else {
     menu_ = CreateMenu(node, start_child_index, show_options);
   }
 
   location_ = location;
 }
 
 void BookmarkMenuDelegate::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
   if (context_menu_.get())
     context_menu_->SetPageNavigator(navigator);
 }
 
 void BookmarkMenuDelegate::SetActiveMenu(const BookmarkNode* node,
                                          int start_index) {
   DCHECK(!parent_menu_item_);
   if (!node_to_menu_map_[node])
-    CreateMenu(node, start_index, HIDE_OTHER_FOLDER);
+    CreateMenu(node, start_index, HIDE_PERMANENT_FOLDERS);
   menu_ = node_to_menu_map_[node];
 }
 
 string16 BookmarkMenuDelegate::GetTooltipText(
     int id,
     const gfx::Point& screen_loc) const {
   DCHECK(menu_id_to_node_map_.find(id) != menu_id_to_node_map_.end());
 
   MenuIDToNodeMap::const_iterator i = menu_id_to_node_map_.find(id);
   DCHECK(i != menu_id_to_node_map_.end());
@@ skipping 74 matching lines @@
 int BookmarkMenuDelegate::GetDropOperation(
     MenuItemView* item,
     const views::DropTargetEvent& event,
     views::MenuDelegate::DropPosition* position) {
   // Should only get here if we have drop data.
   DCHECK(drop_data_.is_valid());
 
   const BookmarkNode* node = menu_id_to_node_map_[item->GetCommand()];
   const BookmarkNode* drop_parent = node->parent();
   int index_to_drop_at = drop_parent->GetIndexOf(node);
-  if (*position == views::MenuDelegate::DROP_AFTER) {
-    if (node == profile_->GetBookmarkModel()->other_node()) {
-      // The other folder is shown after all bookmarks on the bookmark bar.
-      // Dropping after the other folder makes no sense.
-      *position = views::MenuDelegate::DROP_NONE;
-    }
-    index_to_drop_at++;
-  } else if (*position == views::MenuDelegate::DROP_ON) {
-    drop_parent = node;
-    index_to_drop_at = node->child_count();
+  switch (*position) {
+    case views::MenuDelegate::DROP_AFTER:
+      if (node == profile_->GetBookmarkModel()->other_node() ||
+          node == profile_->GetBookmarkModel()->mobile_node()) {
+        // Dropping after these nodes makes no sense.
+        *position = views::MenuDelegate::DROP_NONE;
+      }
+      index_to_drop_at++;
+      break;
+
+    case views::MenuDelegate::DROP_BEFORE:
+      if (node == profile_->GetBookmarkModel()->mobile_node()) {
+        // Dropping before this node makes no sense.
+        *position = views::MenuDelegate::DROP_NONE;
+      }
+      index_to_drop_at++;
+      break;
+
+    case views::MenuDelegate::DROP_ON:
+      drop_parent = node;
+      index_to_drop_at = node->child_count();
+      break;
+
+    default:
+      break;
   }
   DCHECK(drop_parent);
   return bookmark_utils::BookmarkDropOperation(
       profile_, event, drop_data_, drop_parent, index_to_drop_at);
 }
 
 int BookmarkMenuDelegate::OnPerformDrop(
     MenuItemView* menu,
     views::MenuDelegate::DropPosition position,
     const views::DropTargetEvent& event) {
   const BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
   DCHECK(drop_node);
   BookmarkModel* model = profile_->GetBookmarkModel();
   DCHECK(model);
   const BookmarkNode* drop_parent = drop_node->parent();
   DCHECK(drop_parent);
   int index_to_drop_at = drop_parent->GetIndexOf(drop_node);
   switch (position) {
     case views::MenuDelegate::DROP_AFTER:
       index_to_drop_at++;
       break;
 
     case views::MenuDelegate::DROP_ON:
       DCHECK(drop_node->is_folder());
       drop_parent = drop_node;
       index_to_drop_at = drop_node->child_count();
       break;
 
     case views::MenuDelegate::DROP_BEFORE:
-      if (drop_node == model->other_node()) {
-        // This can happen with SHOW_OTHER_FOLDER.
+      if (drop_node == model->other_node() ||
+          drop_node == model->mobile_node()) {
+        // This can happen with SHOW_PERMANENT_FOLDERS.
         drop_parent = model->bookmark_bar_node();
         index_to_drop_at = drop_parent->child_count();
       }
       break;
 
     default:
       break;
   }
 
   int result = bookmark_utils::PerformBookmarkDrop(
@@ skipping 141 matching lines @@
 }
 
 MenuItemView* BookmarkMenuDelegate::CreateMenu(const BookmarkNode* parent,
                                                int start_child_index,
                                                ShowOptions show_options) {
   MenuItemView* menu = new MenuItemView(real_delegate_);
   menu->SetCommand(next_menu_id_++);
   menu_id_to_node_map_[menu->GetCommand()] = parent;
   menu->set_has_icons(true);
   BuildMenu(parent, start_child_index, menu, &next_menu_id_);
-  if (show_options == SHOW_OTHER_FOLDER)
-    BuildOtherFolderMenu(menu, &next_menu_id_);
+  if (show_options == SHOW_PERMANENT_FOLDERS)
+    BuildMenusForPermanentNodes(menu, &next_menu_id_);
   node_to_menu_map_[parent] = menu;
   return menu;
 }
 
-void BookmarkMenuDelegate::BuildOtherFolderMenu(
-    MenuItemView* menu, int* next_menu_id) {
-  const BookmarkNode* other_folder = profile_->GetBookmarkModel()->other_node();
+void BookmarkMenuDelegate::BuildMenusForPermanentNodes(
+    views::MenuItemView* menu,
+    int* next_menu_id) {
+  BookmarkModel* model = profile_->GetBookmarkModel();
+  bool added_separator = false;
+  BuildMenuForPermanentNode(model->other_node(), menu, next_menu_id,
+                            &added_separator);
+  BuildMenuForPermanentNode(model->mobile_node(), menu, next_menu_id,
+                            &added_separator);
+}
+
+void BookmarkMenuDelegate::BuildMenuForPermanentNode(
+    const BookmarkNode* node,
+    MenuItemView* menu,
+    int* next_menu_id,
+    bool* added_separator) {
+  if (node->GetTotalNodeCount() == 1)
+    return;  // No children, don't create a menu.
+
+  if (!*added_separator) {
+    *added_separator = true;
+    menu->AppendSeparator();
+  }
   int id = *next_menu_id;
   (*next_menu_id)++;
   SkBitmap* folder_icon = ResourceBundle::GetSharedInstance().
       GetBitmapNamed(IDR_BOOKMARK_BAR_FOLDER);
   MenuItemView* submenu = menu->AppendSubMenuWithIcon(
-      id,
-      l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OTHER_BOOKMARKED),
-      *folder_icon);
-  BuildMenu(other_folder, 0, submenu, next_menu_id);
-  menu_id_to_node_map_[id] = other_folder;
+      id, node->GetTitle(), *folder_icon);
+  BuildMenu(node, 0, submenu, next_menu_id);
+  menu_id_to_node_map_[id] = node;
 }
 
 void BookmarkMenuDelegate::BuildMenu(const BookmarkNode* parent,
                                      int start_child_index,
                                      MenuItemView* menu,
                                      int* next_menu_id) {
   DCHECK(parent->empty() || start_child_index < parent->child_count());
   for (int i = start_child_index; i < parent->child_count(); ++i) {
     const BookmarkNode* node = parent->GetChild(i);
     int id = *next_menu_id;
@@ skipping 24 matching lines @@
 MenuItemView* BookmarkMenuDelegate::GetMenuByID(int id) {
   for (NodeToMenuMap::const_iterator i = node_to_menu_map_.begin();
        i != node_to_menu_map_.end(); ++i) {
     MenuItemView* menu = i->second->GetMenuItemByID(id);
     if (menu)
       return menu;
   }
 
   return parent_menu_item_ ? parent_menu_item_->GetMenuItemByID(id) : NULL;
 }