[MD Bookmarks] Allow dragging onto empty bookmark lists.

chrome/browser/resources/md_bookmarks/dnd_manager.js

 // Copyright 2017 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.
 
 cr.define('bookmarks', function() {
   /**
    * @param {BookmarkElement} element
    * @return {boolean}
    */
   function isBookmarkItem(element) {
     return element.tagName == 'BOOKMARKS-ITEM';
   }
 
   /**
    * @param {BookmarkElement} element
    * @return {boolean}
    */
   function isBookmarkFolderNode(element) {
     return element.tagName == 'BOOKMARKS-FOLDER-NODE';
   }
 
   /**
+   * @param {BookmarkElement} element
+   * @return {boolean}
+   */
+  function isBookmarkList(element) {
+    return element.tagName == 'BOOKMARKS-LIST';
+  }
+
+  /**
    * @param {Array<!Element>|undefined} path
    * @return {BookmarkElement}
    */
   function getBookmarkElement(path) {
     if (!path)
       return null;
 
     for (var i = 0; i < path.length; i++) {
-      if (isBookmarkItem(path[i]) || isBookmarkFolderNode(path[i]))
+      if (isBookmarkItem(path[i]) || isBookmarkFolderNode(path[i]) ||
+          isBookmarkList(path[i]))
         return path[i];
     }
     return null;
   }
 
   /**
    * @param {BookmarkElement} bookmarkElement
    * @return {BookmarkNode}
    */
   function getBookmarkNode(bookmarkElement) {
@@ skipping 293 matching lines @@
 
       this.dropDestination_ = null;
       this.dropIndicator_.finish();
     },
 
     /**
      * @param {DropDestination} dropDestination
      * @return {{parentId: string, index: number}}
      */
     calculateDropInfo_: function(dropDestination) {
+      if (isBookmarkList(dropDestination.element)) {
+        return {
+          index: 0,
+          parentId: bookmarks.Store.getInstance().data.selectedFolder,
+        };
+      }
+
       var node = getBookmarkNode(dropDestination.element);
       var position = dropDestination.position;
       var index = -1;
       var parentId = node.id;
 
       if (position != DropPosition.ON) {
         var state = bookmarks.Store.getInstance().data;
 
         // Drops between items in the normal list and the sidebar use the drop
         // destination node's parent.
@@ skipping 140 matching lines @@
     /**
      * Determines the valid drop positions for the given target element.
      * @private
      * @param {!BookmarkElement} overElement The element that we are currently
      *     dragging over.
      * @return {DropPosition} An bit field enumeration of valid drop locations.
      */
     calculateValidDropPositions_: function(overElement) {
       var dragInfo = this.dragInfo_;
       var state = bookmarks.Store.getInstance().data;
+      var itemId = overElement.itemId;
 
       // Drags aren't allowed onto the search result list.
-      if (isBookmarkItem(overElement) &&
+      if ((isBookmarkList(overElement) || isBookmarkItem(overElement)) &&
           bookmarks.util.isShowingSearch(state)) {
         return DropPosition.NONE;
       }
 
+      if (isBookmarkList(overElement))
+        itemId = state.selectedFolder;
+
       // Drags of a bookmark onto itself or of a folder into its children aren't
       // allowed.
-      if (dragInfo.isDraggingBookmark(overElement.itemId) ||
-          dragInfo.isDraggingFolderToDescendant(
-              overElement.itemId, state.nodes)) {
+      if (dragInfo.isDraggingBookmark(itemId) ||
+          dragInfo.isDraggingFolderToDescendant(itemId, state.nodes)) {
         return DropPosition.NONE;
       }
 
       var validDropPositions = this.calculateDropAboveBelow_(overElement);
       if (this.canDropOn_(overElement))
         validDropPositions |= DropPosition.ON;
 
       return validDropPositions;
     },
 
     /**
      * @private
      * @param {BookmarkElement} overElement
      * @return {DropPosition}
      */
     calculateDropAboveBelow_: function(overElement) {
       var dragInfo = this.dragInfo_;
       var state = bookmarks.Store.getInstance().data;
 
+      if (isBookmarkList(overElement))
+        return DropPosition.NONE;
+
       // We cannot drop between Bookmarks bar and Other bookmarks.
       if (getBookmarkNode(overElement).parentId == ROOT_NODE_ID)
         return DropPosition.NONE;
 
       var isOverFolderNode = isBookmarkFolderNode(overElement);
 
       // We can only drop between items in the tree if we have any folders.
       if (isOverFolderNode && !dragInfo.isDraggingFolders())
         return DropPosition.NONE;
 
@@ skipping 26 matching lines @@
 
     /**
      * Determine whether we can drop the dragged items on the drop target.
      * @private
      * @param {!BookmarkElement} overElement The element that we are currently
      *     dragging over.
      * @return {boolean} Whether we can drop the dragged items on the drop
      *     target.
      */
     canDropOn_: function(overElement) {
+      // Allow dragging onto empty bookmark lists.
+      if (isBookmarkList(overElement)) {
+        var state = bookmarks.Store.getInstance().data;
+        return state.selectedFolder &&
+            state.nodes[state.selectedFolder].children.length == 0;
+      }
+
       // We can only drop on a folder.
       if (getBookmarkNode(overElement).url)
         return false;
 
       return !this.dragInfo_.isDraggingChildBookmark(overElement.itemId)
     },
   };
 
   return {
     DNDManager: DNDManager,
     DragInfo: DragInfo,
     DropIndicator: DropIndicator,
   };
 });