Align the base of the shelf's context menu to the top edge of the shelf.

ash/shelf/shelf_view.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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/ash_constants.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/scoped_root_window_for_new_windows.h"
+#include "ash/screen_util.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
 #include "ash/shelf/shelf_application_menu_model.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/wm_shelf.h"
@@ skipping 1608 matching lines @@
     }
   }
   // The menu clears |scoped_root_window_for_new_windows_| in OnMenuClosed.
   if (!IsShowingMenu())
     scoped_root_window_for_new_windows_.reset();
 }
 
 void ShelfView::ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
+  // Align the context menu to the edge of the shelf.
+  aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
+  gfx::Rect shelf_bounds =
+      is_overflow_mode()
+          ? (owner_overflow_bubble_->bubble_view()->GetBubbleBounds())

[msw, 2017/05/10 22:18:22]

nit: extra parens not needed here or on the next line.

[msw, 2017/05/11 17:13:39]

Just FYI, I would appreciate it if you respond to all comments, even if you just
use the 'Done' and 'Acknowledged' shortcut buttons. This helps me track how
comments have been addressed.

+          : (ScreenUtil::GetDisplayBoundsWithShelf(shelf_window));
+
+  gfx::Point context_menu_point;
+  switch (wm_shelf_->GetAlignment()) {
+    case SHELF_ALIGNMENT_BOTTOM:
+    case SHELF_ALIGNMENT_BOTTOM_LOCKED:
+      context_menu_point.SetPoint(point.x(),
+                                  shelf_bounds.bottom() - kShelfSize);
+      break;
+    case SHELF_ALIGNMENT_LEFT:
+      context_menu_point.SetPoint(shelf_bounds.x() + kShelfSize, point.y());
+      break;
+    case SHELF_ALIGNMENT_RIGHT:
+      context_menu_point.SetPoint(shelf_bounds.right() - kShelfSize, point.y());
+      break;
+  }
   last_pressed_index_ = -1;
 
   const ShelfItem* item = ShelfItemForView(source);
   if (!item) {
-    ShellPort::Get()->ShowContextMenu(point, source_type);
+    ShellPort::Get()->ShowContextMenu(context_menu_point, source_type);
     return;
   }
 
   std::unique_ptr<ui::MenuModel> context_menu_model(
       Shell::Get()->shell_delegate()->CreateContextMenu(wm_shelf_, item));
   if (!context_menu_model)
     return;
 
   context_menu_id_ = item ? item->id : ShelfID();
-  ShowMenu(std::move(context_menu_model), source, point, true, source_type,
-           nullptr);
+  ShowMenu(std::move(context_menu_model), source, context_menu_point, true,
+           source_type, nullptr);
 }
 
 void ShelfView::ShowMenu(std::unique_ptr<ui::MenuModel> menu_model,
                          views::View* source,
                          const gfx::Point& click_point,
                          bool context_menu,
                          ui::MenuSourceType source_type,
                          views::InkDrop* ink_drop) {
   menu_model_ = std::move(menu_model);
   menu_model_adapter_.reset(new views::MenuModelAdapter(
       menu_model_.get(),
       base::Bind(&ShelfView::OnMenuClosed, base::Unretained(this), ink_drop)));
 
   closing_event_time_ = base::TimeTicks();
   int run_types = 0;
   if (context_menu)
-    run_types |= views::MenuRunner::CONTEXT_MENU;
+    run_types |=
+        views::MenuRunner::CONTEXT_MENU | views::MenuRunner::SHELF_CONTEXT_MENU;
   launcher_menu_runner_.reset(
       new views::MenuRunner(menu_model_adapter_->CreateMenu(), run_types));
 
   // Place new windows on the same display as the button that spawned the menu.
   WmWindow* window = WmWindow::Get(source->GetWidget()->GetNativeWindow());
   scoped_root_window_for_new_windows_.reset(
       new ScopedRootWindowForNewWindows(window->GetRootWindow()));
 
   views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
   gfx::Rect anchor = gfx::Rect(click_point, gfx::Size());
@@ skipping 17 matching lines @@
         break;
       case SHELF_ALIGNMENT_LEFT:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_RIGHT;
         break;
       case SHELF_ALIGNMENT_RIGHT:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_LEFT;
         break;
     }
   }
 
+  // Distinguish the touch events that triggered on the bottom shelf or

[msw, 2017/05/10 22:18:22]

Should this be clobbering the |menu_alignment| values assigned in the |if
(!context_menu)| block above? If so, remove those assignments? (you should test
the application menu for items with multiple windows)

[minch1, 2017/05/11 16:34:02]

Oh, here will reassign the menu_alignment if |if(!context_menu)| happens, there
are different alignments. I think I should put following lines in |else| block
instead. 

[msw, 2017/05/11 17:13:39]

aside: it'd be nice if UX wanted both menus to look/act the same.

+  // left / right shelf. Since they should have different |MenuAnchorPosition|.
+  if (wm_shelf_->IsHorizontalAlignment())
+    menu_alignment = views::MENU_ANCHOR_FIXED_BOTTOMCENTER;
+  else
+    menu_alignment = views::MENU_ANCHOR_SIDECENTER;
+
   // NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
   launcher_menu_runner_->RunMenuAt(source->GetWidget(), nullptr, anchor,
                                    menu_alignment, source_type);
 }
 
 void ShelfView::OnMenuClosed(views::InkDrop* ink_drop) {
   context_menu_id_ = ShelfID();
 
   // Hide the hide overflow bubble after showing a context menu for its items.
   if (owner_overflow_bubble_)
@@ skipping 66 matching lines @@
   // Bail if dragging has already begun, or if no item has been pressed.
   if (dragging() || !drag_view_)
     return false;
 
   // Dragging only begins once the pointer has travelled a minimum distance.
   if ((std::abs(event.x() - drag_origin_.x()) < kMinimumDragDistance) &&
       (std::abs(event.y() - drag_origin_.y()) < kMinimumDragDistance)) {
     return false;
   }
 
-  // Touch dragging only begins after a dealy from the press event. This
+  // Touch dragging only begins after a delay from the press event. This
   // prevents accidental dragging on swipe or scroll gestures.
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash