Show the Managed Bookmarks folder in the views UI.

chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.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/ui/views/bookmarks/bookmark_menu_delegate.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_drag_drop_views.h"
 #include "chrome/browser/ui/views/event_utils.h"
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "content/public/browser/page_navigator.h"
@@ skipping 44 matching lines @@
                                 MenuItemView* parent,
                                 const BookmarkNode* node,
                                 int start_child_index,
                                 ShowOptions show_options,
                                 BookmarkLaunchLocation location) {
   GetBookmarkModel()->AddObserver(this);
   real_delegate_ = real_delegate;
   location_ = location;
   if (parent) {
     parent_menu_item_ = parent;
+
+    // Add a separator if there are existing items in the menu, and if the
+    // current node has children. If |node| is the bookmark bar then the
+    // managed node is shown as its first child, if it's not empty.
+    BookmarkModel* model = GetBookmarkModel();
+    ChromeBookmarkClient* client = GetChromeBookmarkClient();
+    bool show_managed = show_options == SHOW_PERMANENT_FOLDERS &&
+                        node == model->bookmark_bar_node() &&
+                        !client->managed_node()->empty();
+    bool has_children =
+        (start_child_index < node->child_count()) || show_managed;
     int initial_count = parent->GetSubmenu() ?
         parent->GetSubmenu()->GetMenuItemCount() : 0;
-    if ((start_child_index < node->child_count()) &&
-        (initial_count > 0)) {
+    if (has_children && initial_count > 0)
       parent->AppendSeparator();
-    }
+    if (show_managed)
+      BuildMenuForManagedNode(parent, &next_menu_id_);
     BuildMenu(node, start_child_index, parent, &next_menu_id_);
     if (show_options == SHOW_PERMANENT_FOLDERS)
       BuildMenusForPermanentNodes(parent, &next_menu_id_);
   } else {
     menu_ = CreateMenu(node, start_child_index, show_options);
   }
 }
 
 void BookmarkMenuDelegate::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
   if (context_menu_.get())
     context_menu_->SetPageNavigator(navigator);
 }
 
 BookmarkModel* BookmarkMenuDelegate::GetBookmarkModel() {
   return BookmarkModelFactory::GetForProfile(profile_);
 }
 
+ChromeBookmarkClient* BookmarkMenuDelegate::GetChromeBookmarkClient() {
+  return BookmarkModelFactory::GetChromeBookmarkClientForProfile(profile_);
+}
+
 void BookmarkMenuDelegate::SetActiveMenu(const BookmarkNode* node,
                                          int start_index) {
   DCHECK(!parent_menu_item_);
   if (!node_to_menu_map_[node])
     CreateMenu(node, start_index, HIDE_PERMANENT_FOLDERS);
   menu_ = node_to_menu_map_[node];
 }
 
 base::string16 BookmarkMenuDelegate::GetTooltipText(
     int id,
@@ skipping 155 matching lines @@
         // This can happen with SHOW_PERMANENT_FOLDERS.
         drop_parent = model->bookmark_bar_node();
         index_to_drop_at = drop_parent->child_count();
       }
       break;
 
     default:
       break;
   }
 
+  bool copy = event.source_operations() == ui::DragDropTypes::DRAG_COPY;
   return chrome::DropBookmarks(profile_, drop_data_,
-                               drop_parent, index_to_drop_at);
+                               drop_parent, index_to_drop_at, copy);
 }
 
 bool BookmarkMenuDelegate::ShowContextMenu(MenuItemView* source,
                                            int id,
                                            const gfx::Point& p,
                                            ui::MenuSourceType source_type) {
   DCHECK(menu_id_to_node_map_.find(id) != menu_id_to_node_map_.end());
   std::vector<const BookmarkNode*> nodes;
   nodes.push_back(menu_id_to_node_map_[id]);
   bool close_on_delete = !parent_menu_item_ &&
@@ skipping 117 matching lines @@
   is_mutating_model_ = false;
 }
 
 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);
+  bool show_permanent = show_options == SHOW_PERMANENT_FOLDERS;
+  if (show_permanent && parent == GetBookmarkModel()->bookmark_bar_node())
+    BuildMenuForManagedNode(menu, &next_menu_id_);
   BuildMenu(parent, start_child_index, menu, &next_menu_id_);
-  if (show_options == SHOW_PERMANENT_FOLDERS)
+  if (show_permanent)
     BuildMenusForPermanentNodes(menu, &next_menu_id_);
   return menu;
 }
 
 void BookmarkMenuDelegate::BuildMenusForPermanentNodes(
     views::MenuItemView* menu,
     int* next_menu_id) {
   BookmarkModel* model = GetBookmarkModel();
   bool added_separator = false;
   BuildMenuForPermanentNode(model->other_node(), menu, next_menu_id,
@@ skipping 22 matching lines @@
   }
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia* folder_icon = rb->GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER);
   MenuItemView* submenu = menu->AppendSubMenuWithIcon(
       id, node->GetTitle(), *folder_icon);
   BuildMenu(node, 0, submenu, next_menu_id);
   menu_id_to_node_map_[id] = node;
 }
 
+void BookmarkMenuDelegate::BuildMenuForManagedNode(
+    MenuItemView* menu,
+    int* next_menu_id) {
+  // Don't add a separator for this menu.
+  bool added_separator = true;
+  const BookmarkNode* node = GetChromeBookmarkClient()->managed_node();
+  // TODO(joaodasilva): use the "managed bookmark folder" icon here.
+  // http://crbug.com/49598
+  BuildMenuForPermanentNode(node, menu, next_menu_id, &added_separator);
+}
+
 void BookmarkMenuDelegate::BuildMenu(const BookmarkNode* parent,
                                      int start_child_index,
                                      MenuItemView* menu,
                                      int* next_menu_id) {
   node_to_menu_map_[parent] = menu;
   DCHECK(parent->empty() || start_child_index < parent->child_count());
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   for (int i = start_child_index; i < parent->child_count(); ++i) {
     const BookmarkNode* node = parent->GetChild(i);
     const int id = *next_menu_id;
@@ skipping 18 matching lines @@
       BuildMenu(node, 0, submenu, next_menu_id);
     } else {
       NOTREACHED();
     }
   }
 }
 
 bool BookmarkMenuDelegate::IsOutsideMenuIdRange(int menu_id) const {
   return menu_id < min_menu_id_ || menu_id > max_menu_id_;
 }