Refactors some of the bookmark drag and drop code into a separate...

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2006-2008 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/views/bookmark_bar_view.h"
 
 #include <limits>
 
 #include "base/base_drag_source.h"
 #include "base/gfx/skia_utils.h"
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/bookmark_bar_context_menu_controller.h"
+#include "chrome/browser/bookmarks/bookmark_drag_utils.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/drag_utils.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/page_navigator.h"
@@ skipping 118 matching lines @@
 static const int kInstructionsPadding = 6;
 
 // Color of the instructional text.
 static const SkColor kInstructionsColor = SkColorSetRGB(128, 128, 142);
 
 // Tag for the other button.
 static const int kOtherFolderButtonTag = 1;
 
 namespace {
 
-// Calculates the drop operation given the event and supported set of
-// operations.
-int PreferredDropOperation(const DropTargetEvent& event, int operation) {
-  int common_ops = (event.GetSourceOperations() & operation);
-  if (!common_ops)
-    return 0;
-  if (DragDropTypes::DRAG_COPY & common_ops)
-    return DragDropTypes::DRAG_COPY;
-  if (DragDropTypes::DRAG_LINK & common_ops)
-    return DragDropTypes::DRAG_LINK;
-  if (DragDropTypes::DRAG_MOVE & common_ops)
-    return DragDropTypes::DRAG_MOVE;
-  return DragDropTypes::DRAG_NONE;
-}
-
 // Returns the tooltip text for the specified url and title. The returned
 // text is clipped to fit within the bounds of the monitor.
 //
 // Note that we adjust the direction of both the URL and the title based on the
 // locale so that pure LTR strings are displayed properly in RTL locales.
 static std::wstring CreateToolTipForURLAndTitle(const gfx::Point& screen_loc,
                                                 const GURL& url,
                                                 const std::wstring& title,
                                                 const std::wstring& languages) {
   const gfx::Rect monitor_bounds = win_util::GetMonitorBoundsForRect(
@@ skipping 1483 matching lines @@
     // Mouse is over 'other' folder.
     *is_over_other = true;
     *drop_on = true;
     found = true;
   } else if (!GetBookmarkButtonCount()) {
     // No bookmarks, accept the drop.
     *index = 0;
     int ops = data.GetFirstNode(profile_)
         ? DragDropTypes::DRAG_MOVE
         : DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_LINK;
-    return PreferredDropOperation(event, ops);
+    return bookmark_drag_utils::PreferredDropOperation(event, ops);
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
        GetBookmarkButton(i)->IsVisible() && !found; i++) {
     views::TextButton* button = GetBookmarkButton(i);
     int button_x = mirrored_x - button->x();
     int button_w = button->width();
     if (button_x < button_w) {
       found = true;
       BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(i);
@@ skipping 56 matching lines @@
   } else {
     return CalculateDropOperation(event, data, model_->GetBookmarkBarNode(),
                                   *index);
   }
 }
 
 int BookmarkBarView::CalculateDropOperation(const DropTargetEvent& event,
                                             const BookmarkDragData& data,
                                             BookmarkNode* parent,
                                             int index) {
-  if (!CanDropAt(data, parent, index))
+  if (data.IsFromProfile(profile_) && data.size() > 1)
+    // Currently only accept one dragged node at a time.
+    return DragDropTypes::DRAG_NONE;
+
+  if (!bookmark_drag_utils::IsValidDropLocation(profile_, data, parent, index))
     return DragDropTypes::DRAG_NONE;
 
   if (data.GetFirstNode(profile_)) {
     // User is dragging from this profile: move.
     return DragDropTypes::DRAG_MOVE;
   } else {
     // User is dragging from another app, copy.
-    return PreferredDropOperation(
+    return bookmark_drag_utils::PreferredDropOperation(
         event, DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_LINK);
   }
 }
 
-bool BookmarkBarView::CanDropAt(const BookmarkDragData& data,
-                                BookmarkNode* parent,
-                                int index) {
-  DCHECK(data.is_valid());
-  BookmarkNode* dragged_node = data.GetFirstNode(profile_);
-  if (dragged_node) {
-    if (dragged_node->GetParent() == parent) {
-      const int existing_index = parent->IndexOfChild(dragged_node);
-      if (index == existing_index || existing_index + 1 == index)
-        return false;
-    }
-    // Allow the drop only if the node we're going to drop on isn't a
-    // descendant of the dragged node.
-    BookmarkNode* test_node = parent;
-    while (test_node && test_node != dragged_node)
-      test_node = test_node->GetParent();
-    return (test_node == NULL);
-  }  // else case clones, always allow.
-  return true;
-}
-
-
 int BookmarkBarView::PerformDropImpl(const BookmarkDragData& data,
                                      BookmarkNode* parent_node,
                                      int index) {
   BookmarkNode* dragged_node = data.GetFirstNode(profile_);
   if (dragged_node) {
     // Drag from same profile, do a move.
     model_->Move(dragged_node, parent_node, index);
     return DragDropTypes::DRAG_MOVE;
   } else if (data.has_single_url()) {
     // New URL, add it at the specified location.
     std::wstring title = data.elements[0].title;
     if (title.empty()) {
       // No title, use the host.
       title = UTF8ToWide(data.elements[0].url.host());
       if (title.empty())
         title = l10n_util::GetString(IDS_BOOMARK_BAR_UNKNOWN_DRAG_TITLE);
     }
     model_->AddURL(parent_node, index, title, data.elements[0].url);
     return DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_LINK;
   } else {
     // Dropping a group from different profile. Always accept.
-    CloneDragData(data.elements[0], parent_node, index);
+    bookmark_drag_utils::CloneDragData(model_, data.elements, parent_node,
+                                       index);
     return DragDropTypes::DRAG_COPY;
   }
 }
 
-void BookmarkBarView::CloneDragData(const BookmarkDragData::Element& element,
-                                    BookmarkNode* parent,
-                                    int index_to_add_at) {
-  DCHECK(model_);
-  if (element.is_url) {
-    model_->AddURL(parent, index_to_add_at, element.title, element.url);
-  } else {
-    BookmarkNode* new_folder = model_->AddGroup(parent, index_to_add_at,
-                                                element.title);
-    for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
-      CloneDragData(element.children[i], new_folder, i);
-  }
-}
-
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
     if (!GetBookmarkButton(i)->IsVisible())
       return i;
   }
   return bb_count;
 }
 
 void BookmarkBarView::StartThrobbing() {
@@ skipping 32 matching lines @@
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
   throbbing_view_ = NULL;
 }