Adjust BrowserActionsContainer drag and drop to work for overflow

chrome/browser/ui/views/toolbar/browser_actions_container.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/ui/views/toolbar/browser_actions_container.h"
 
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 82 matching lines @@
     return border.Pass();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChevronMenuButton);
 };
 
 }  // namespace
 
 // static
 bool BrowserActionsContainer::disable_animations_during_testing_ = false;

[Peter Kasting, 2014/07/21 20:24:08]

Nit: Put this below the "BrowserActionsContainer" divider comment below.

[Devlin, 2014/07/22 17:30:46]

Done.

 
+struct BrowserActionsContainer::DropPosition {

[Peter Kasting, 2014/07/21 20:24:08]

Nit: Consider a "// BrowserActionsContainer::DropPosition ---..." or similar
divider about this class (up to you)

[Devlin, 2014/07/22 17:30:46]

SGTM. Done.

+  DropPosition(size_t row, size_t icon_in_row);
+  ~DropPosition();

[Peter Kasting, 2014/07/21 20:24:08]

Nit: Is declaring this destructor necessary?

[Devlin, 2014/07/22 17:30:47]

For some reason, I thought it was chrome/google style.  But I can't find a rule
indicating it is, so taken out.

+
+  // The (0-indexed) row into which the action will be dropped.
+  size_t row;
+
+  // The (0-indexed) icon in the row before the action will be dropped.
+  size_t icon_in_row;
+};
+
+BrowserActionsContainer::DropPosition::DropPosition(
+    size_t row, size_t icon_in_row)
+    : row(row), icon_in_row(icon_in_row) {
+}
+
+BrowserActionsContainer::DropPosition::~DropPosition() {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionsContainer
 
 BrowserActionsContainer::BrowserActionsContainer(
     Browser* browser,
     View* owner_view,
     BrowserActionsContainer* main_container)
     : profile_(browser->profile()),
       browser_(browser),
       owner_view_(owner_view),
       main_container_(main_container),
       popup_(NULL),
       popup_button_(NULL),
       model_(NULL),
       container_width_(0),
       resize_area_(NULL),
       chevron_(NULL),
       overflow_menu_(NULL),
       suppress_chevron_(false),
       resize_amount_(0),
       animation_target_size_(0),
-      drop_indicator_position_(-1),
       task_factory_(this),
       show_menu_task_factory_(this) {
   set_id(VIEW_ID_BROWSER_ACTION_TOOLBAR);
 
   model_ = extensions::ExtensionToolbarModel::Get(browser->profile());
   if (model_)
     model_->AddObserver(this);
 
   bool overflow_experiment =
       extensions::FeatureSwitch::extension_action_redesign()->IsEnabled();
@@ skipping 215 matching lines @@
       // Ensure that any browser actions shown in the main view are hidden in
       // the overflow view.
       browser_action_views_[i]->SetVisible(false);
     }
 
     for (size_t i = main_container_->VisibleBrowserActionsAfterAnimation();
          i < browser_action_views_.size(); ++i) {
       BrowserActionView* view = browser_action_views_[i];
       size_t index = i - main_container_->VisibleBrowserActionsAfterAnimation();
       int row_index = static_cast<int>(index) / kIconsPerMenuRow;
-      int x = (index * IconWidth(true)) -
+      int x = kItemSpacing + (index * IconWidth(true)) -

[Peter Kasting, 2014/07/21 20:24:08]

So, we have kItemSpacing to the left of all the icons, but not between each pair
of icons?

[Devlin, 2014/07/22 17:30:46]

We do have it between each pair of icons, but IconWidth() is somewhat
unfortunately done. The bool passed in indicates "include padding", which, if
true, returns the width of the icon + kItemSpacing.  The extra kItemSpacing here
is to account for the spacing before each icon (e.g., for the 0th index, we
still have 1 spacing, for the 1st index, we have 2 spacing, etc).

           (row_index * IconWidth(true) * kIconsPerMenuRow);
       gfx::Rect rect_bounds(
           x, IconHeight() * row_index, icon_width, IconHeight());
       view->SetBoundsRect(rect_bounds);
       view->SetVisible(true);
     }
   } else {
     for (BrowserActionViews::const_iterator it = browser_action_views_.begin();
          it < browser_action_views_.end(); ++it) {
       BrowserActionView* view = *it;
@@ skipping 27 matching lines @@
 int BrowserActionsContainer::OnDragUpdated(
     const ui::DropTargetEvent& event) {
   // First check if we are above the chevron (overflow) menu.
   if (GetEventHandlerForPoint(event.location()) == chevron_) {
     if (!show_menu_task_factory_.HasWeakPtrs() && !overflow_menu_)
       StartShowFolderDropMenuTimer();
     return ui::DragDropTypes::DRAG_MOVE;
   }
   StopShowFolderDropMenuTimer();
 
-  // TODO(devlin): This calculation needs to take 'overflow' mode into account
-  // once the wrench menu becomes a drag target for browser action icons.
-
   // Figure out where to display the indicator.  This is a complex calculation:
 
   // First, we figure out how much space is to the left of the icon area, so we
-  // can calculate the true offset into the icon area.
-  int width_before_icons = ToolbarView::kStandardSpacing;
-  if (chevron_ && base::i18n::IsRTL()) {
-    width_before_icons +=
-        chevron_->GetPreferredSize().width() + kChevronSpacing;
-  }
-  int offset_into_icon_area = event.x() - width_before_icons;
+  // can calculate the true offset into the icon area. The easiest way to do
+  // this is to just find where the first icon starts.
+  int width_before_icons =
+      browser_action_views_[GetFirstVisibleIconIndex()]->x();
+
+  // If we're right-to-left, we flip the mirror the event.x() so that our
+  // calculations are consistent with left-to-right.
+  int offset_into_icon_area =
+    (base::i18n::IsRTL() ? width() - event.x() : event.x()) -

[Peter Kasting, 2014/07/21 20:24:08]

Nit: Use "GetMirroredXInView(event.x())"; indent 2, not 4

[Devlin, 2014/07/22 17:30:46]

Done.

+    width_before_icons;
+
+  // Next, figure out what row we're on. This only matters for overflow mode,
+  // but the calculation is the same for both.
+  int row_index = event.y() / IconHeight();
+
+  // Sanity check - we should never be on a different row in the main container.
+  DCHECK(in_overflow_mode() || row_index == 0);
 
   // Next, we determine which icon to place the indicator in front of.  We want
   // to place the indicator in front of icon n when the cursor is between the
   // midpoints of icons (n - 1) and n.  To do this we take the offset into the
   // icon area and transform it as follows:
   //
   // Real icon area:
   //   0   a     *  b        c
   //   |   |        |        |
   //   |[IC|ON]  [IC|ON]  [IC|ON]
   // We want to be before icon 0 for 0 < x <= a, icon 1 for a < x <= b, etc.
   // Here the "*" represents the offset into the icon area, and since it's
   // between a and b, we want to return "1".
   //
   // Transformed "icon area":
   //   0        a     *  b        c
   //   |        |        |        |
   //   |[ICON]  |[ICON]  |[ICON]  |
   // If we shift both our offset and our divider points later by half an icon
   // plus one spacing unit, then it becomes very easy to calculate how many
   // divider points we've passed, because they're the multiples of "one icon
   // plus padding".
   int before_icon_unclamped = (offset_into_icon_area + (IconWidth(false) / 2) +
       kItemSpacing) / IconWidth(true);
 
+  // We need to figure out how many icons are visible on the relevant row.
+  // In the main container, this will just be the visible actions.
+  int visible_icons_on_row = VisibleBrowserActionsAfterAnimation();
+  if (in_overflow_mode()) {
+    // If this is the final row of the overflow, then this is the remainder of
+    // visible icons. Otherwise, it's a full row (kIconsPerRow).
+    visible_icons_on_row =
+        row_index == (visible_icons_on_row / kIconsPerMenuRow) ?
+            visible_icons_on_row % kIconsPerMenuRow :
+            kIconsPerMenuRow;
+  }
+
   // Because the user can drag outside the container bounds, we need to clamp to
   // the valid range.  Note that the maximum allowable value is (num icons), not
   // (num icons - 1), because we represent the indicator being past the last
   // icon as being "before the (last + 1) icon".
-  int before_icon = std::min(std::max(before_icon_unclamped, 0),
-                             static_cast<int>(VisibleBrowserActions()));
+  int before_icon_in_row =
+      std::min(std::max(before_icon_unclamped, 0), visible_icons_on_row);
 
-  // Now we convert back to a pixel offset into the container.  We want to place
-  // the center of the drop indicator at the midpoint of the space before our
-  // chosen icon.
-  SetDropIndicator(width_before_icons + (before_icon * IconWidth(true)) -
-      (kItemSpacing / 2));
+  SetDropPosition(row_index, before_icon_in_row);
 
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void BrowserActionsContainer::OnDragExited() {
   StopShowFolderDropMenuTimer();
-  drop_indicator_position_ = -1;
+  ResetDropPosition();
   SchedulePaint();
 }
 
 int BrowserActionsContainer::OnPerformDrop(
     const ui::DropTargetEvent& event) {
   BrowserActionDragData data;
   if (!data.Read(event.data()))
     return ui::DragDropTypes::DRAG_NONE;
 
   // Make sure we have the same view as we started with.
   DCHECK_EQ(browser_action_views_[data.index()]->button()->extension()->id(),
             data.id());
   DCHECK(model_);
 
-  size_t i = 0;
-  for (; i < browser_action_views_.size(); ++i) {
-    int view_x = browser_action_views_[i]->GetMirroredBounds().x();
-    if (!browser_action_views_[i]->visible() ||
-        (base::i18n::IsRTL() ? (view_x < drop_indicator_position_) :
-            (view_x >= drop_indicator_position_))) {
-      // We have reached the end of the visible icons or found one that has a
-      // higher x position than the drop point.
-      break;
-    }
-  }
-
+  size_t i =
+      drop_position_->row * kIconsPerMenuRow + drop_position_->icon_in_row;
+  if (in_overflow_mode())
+    i += GetFirstVisibleIconIndex();
   // |i| now points to the item to the right of the drop indicator*, which is
   // correct when dragging an icon to the left. When dragging to the right,
   // however, we want the icon being dragged to get the index of the item to
   // the left of the drop indicator, so we subtract one.
   // * Well, it can also point to the end, but not when dragging to the left. :)
   if (i > data.index())
     --i;
 
   if (profile_->IsOffTheRecord())
     i = model_->IncognitoIndexToOriginal(i);
@@ skipping 180 matching lines @@
 
   for (BrowserActionViews::iterator it = browser_action_views_.begin();
        it != browser_action_views_.end(); ++it) {
     BrowserActionButton* button = (*it)->button();
     if (button && button->extension() == extension)
       return ShowPopup(button, ExtensionPopup::SHOW, should_grant);
   }
   return false;
 }
 
+size_t BrowserActionsContainer::GetFirstVisibleIconIndex() const {
+  return in_overflow_mode() ? model_->GetVisibleIconCount() : 0;
+}
+
 void BrowserActionsContainer::HidePopup() {
   // Remove this as an observer and clear |popup_| and |popup_button_| here,
   // since we might change them before OnWidgetDestroying() gets called.
   if (popup_) {
     popup_->GetWidget()->RemoveObserver(this);
     popup_->GetWidget()->Close();
     popup_ = NULL;
   }
   if (popup_button_) {
     popup_button_->SetButtonNotPushed();
@@ skipping 17 matching lines @@
 void BrowserActionsContainer::OnPaint(gfx::Canvas* canvas) {
   // If the views haven't been initialized yet, wait for the next call to
   // paint (one will be triggered by entering highlight mode).
   if (model_->is_highlighting() && !browser_action_views_.empty()) {
     views::Painter::PaintPainterAt(
         canvas, highlight_painter_.get(), GetLocalBounds());
   }
 
   // TODO(sky/glen): Instead of using a drop indicator, animate the icons while
   // dragging (like we do for tab dragging).
-  if (drop_indicator_position_ > -1) {
+  if (drop_position_.get()) {
     // The two-pixel width drop indicator.
     static const int kDropIndicatorWidth = 2;
-    gfx::Rect indicator_bounds(
-        drop_indicator_position_ - (kDropIndicatorWidth / 2),
-        0,
-        kDropIndicatorWidth,
-        height());
+
+    // Convert back to a pixel offset into the container. We want to place
+    // the center of the drop indicator at the midpoint of the space before
+    // the drop position's referenced icon.
+    // This is:
+    //     The width before the first icon, plus
+    //     The width of all icons before the target icon in the row, minus
+    //     Half the spacing between the target icon and the previous icon, minus
+    //     Half the width of the drop indicator, so it's centered.
+    int drop_indicator_x =
+        browser_action_views_[GetFirstVisibleIconIndex()]->x() +
+        drop_position_->icon_in_row * IconWidth(true) -
+        kItemSpacing / 2 -
+        kDropIndicatorWidth / 2;
+
+    // Mirror the x if it's RTL. Why the extra -1? Because kItemSpacing is 3,
+    // so kItemSpacing / 2 = 1. In order to draw the drop indicator at the same
+    // point in RTL, we have to subtract the extra difference (otherwise it
+    // draws to far to the right).

[Peter Kasting, 2014/07/21 20:24:08]

Nit: to far -> too far

This logic doesn't really make sense to me, though.  This is mathematically
equivalent to just having not inserted the "kItemSpacing / 2" in the calculation
above (when we're RTL).  It seems like if there is a rounding issue here, we'd
want to shift things further right by 1 px in RTL, not further left.

Maybe you can give some screnshots to illustrate the issue here?

[Devlin, 2014/07/22 17:30:46]

Yeah, it's confusing. :)  So, in LTR, we shift things "closer to the icon"
(because we take kItemSpacing / 2 = 3 / 2 = 1, so we only move one pixel away
from the icon).  When we mirror this to RTL, to get the same effect, "closer to
the icon" requires an offset of 2 (because it's mirrored), so we basically want
kItemSpacing / 2 = 2.  Since we subtract kItemSpacing, to make up the
difference, we subtract 1.

And, of course, screenshots are worth 1000 words.
http://imgur.com/PtFGQ4f
The RTL is most apparently wrong without the -1 when dragging to the far right
(i.e., closer to the address bar) as the drop indicator actually gets cut off.

[Peter Kasting, 2014/07/22 18:21:11]

The screenshots are pretty clear that what you're doing makes sense.

It still boggles my mind, though.  When you say "Since we subtract kItemSpacing,
to make up the difference, we subtract 1", my response is, "But we subtract that
value before we mirror everything -- and mirroring flips all the signs.  So
effectively, after we mirror, we've 'added' kItemSpacing/2, and now we're
undoing that, rather than adding to it."

Another way of saying this is, if you replaced "kItemSpacing / 2" with "2",
eliminated the RTL-specific subtraction, and then ran in RTL mode, I'd expect
you to get a different result than your current code.  If I'm right, it suggests
your justification here is a bit wonky, and you're not really trying to subtract
"kItemSpacing / 2" in the first place, you really just have an LTR-specific "-1"
for some reason.

Consider testing the above theory and, if it's correct, thinking more deeply
about how the code and comments here should read.

[Devlin, 2014/07/22 20:29:32]

Ah!  You're quite right, there's a couple things wrong here (even in the old
code).

We should not be subtracting kDropIndicatorWidth / 2, but rather
kDropIndicatorWidth, as this is used to set the bounds (which need the starting
x, not the center).  We add in an extra pixel, because kItemSpacing is odd, and
it looks better a bit closer to the icon and farther from the address bar. 
Then, we *do* need an RTL correction, because FillRect doesn't use RTL bounds
(hence why we mirror in the first place).  Because of this, it fills LTR, and we
actually need to shift the bounds of the rect by kDropIndicatorWidth to
compensate.

+    if (base::i18n::IsRTL())
+      drop_indicator_x = width() - drop_indicator_x - 1;

[Peter Kasting, 2014/07/21 20:24:08]

Nit: MirroredXInView()

[Devlin, 2014/07/22 17:30:46]

Done.

+
+    // The y is simply the start of the row (which for the main container is
+    // always 0).
+    int drop_indicator_y = IconHeight() * drop_position_->row;
+
+    gfx::Rect indicator_bounds(drop_indicator_x,
+                               drop_indicator_y,
+                               kDropIndicatorWidth,
+                               IconHeight());
 
     // Color of the drop indicator.
     static const SkColor kDropIndicatorColor = SK_ColorBLACK;
     canvas->FillRect(indicator_bounds, kDropIndicatorColor);
   }
 }
 
 void BrowserActionsContainer::OnThemeChanged() {
   LoadImages();
 }
@@ skipping 190 matching lines @@
 void BrowserActionsContainer::StartShowFolderDropMenuTimer() {
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BrowserActionsContainer::ShowDropFolder,
                  show_menu_task_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(views::GetMenuShowDelay()));
 }
 
 void BrowserActionsContainer::ShowDropFolder() {
   DCHECK(!overflow_menu_);
-  SetDropIndicator(-1);
+  ResetDropPosition();
   overflow_menu_ =
       new BrowserActionOverflowMenuController(this,
                                               browser_,
                                               chevron_,
                                               browser_action_views_,
                                               VisibleBrowserActions(),
                                               true);
   overflow_menu_->set_observer(this);
   overflow_menu_->RunMenu(GetWidget());
 }
 
-void BrowserActionsContainer::SetDropIndicator(int x_pos) {
-  if (drop_indicator_position_ != x_pos) {
-    drop_indicator_position_ = x_pos;
+void BrowserActionsContainer::SetDropPosition(size_t row, size_t icon_in_row) {

[Peter Kasting, 2014/07/21 20:24:08]

Nit: This is only called once.  It might be clearer to do this in the caller.

If you use my suggestion about storing this member by value instead of pointer
(see comments in .h), we could do something like:

  const DropPosition old_pos(drop_position_);
  drop_position_ = DropPosition(row, icon_in_row);
  if (drop_position_ != old_pos)
    SchedulePaint();

[Devlin, 2014/07/22 17:30:46]

Inlined.  See comment in the .h about the rest.

+  if (!drop_position_.get() ||
+      !(drop_position_->row == row &&
+        drop_position_->icon_in_row == icon_in_row)) {
+    drop_position_.reset(new DropPosition(row, icon_in_row));
     SchedulePaint();
   }
 }
 
+void BrowserActionsContainer::ResetDropPosition() {

[Peter Kasting, 2014/07/21 20:24:08]

I'm not convinced having this is preferable to just calling reset() directly
inline in the callers.

[Devlin, 2014/07/22 17:30:46]

Agreed - I put this in for parity with SetDropPosition, but it's really not
needed (especially if we inline SetDropPosition()).

+  drop_position_.reset();
+}
+
 int BrowserActionsContainer::IconCountToWidth(int icons,
                                               bool display_chevron) const {
   if (icons < 0)
     icons = browser_action_views_.size();
   if ((icons == 0) && !display_chevron)
     return ToolbarView::kStandardSpacing;
   int icons_size =
       (icons == 0) ? 0 : ((icons * IconWidth(true)) - kItemSpacing);
   int chevron_size = chevron_ && display_chevron ?
       (kChevronSpacing + chevron_->GetPreferredSize().width()) : 0;
@@ skipping 87 matching lines @@
                                      views::BubbleBorder::TOP_RIGHT,
                                      show_action);
   popup_->GetWidget()->AddObserver(this);
   popup_button_ = button;
 
   // Only set button as pushed if it was triggered by a user click.
   if (should_grant)
     popup_button_->SetButtonPushed();
   return true;
 }