desktop-pwas: Add "Extensions" menu item to web app windows

This CL:
 - Hides the Extensions icon in web app windows unless the Extensions
   menu is opened.
 - Adds an "Extensions" menu item to the web app three dot menu to
   open the Extensions menu.

This change is behind the DesktopPWAsElideExtensionsMenu flag.

Minor change in behaviour to browser window extension menu
(regardless of flag state): When the last extension is removed the
container will wait for its layout animation to complete before hiding
itself.

Before:
https://bugs.chromium.org/p/chromium/issues/attachment?aid=480233&signed_aid=3saz6ZsTFVwVy1W5EoAbXQ==&inline=1

After:
https://bugs.chromium.org/p/chromium/issues/attachment?aid=480997&signed_aid=A3ERk4v_G7ywyM9S3Wx10A==&inline=1

Bug: 1155421
Change-Id: I80d5b382610895021c2cdf861d253edbdabe8630
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2573897
Commit-Queue: Alan Cutter <alancutter@chromium.org>
Reviewed-by: Dana Fried <dfried@chromium.org>
Cr-Commit-Position: refs/heads/master@{#838031}

chrome/browser/ui/views/extensions/extensions_menu_view_browsertest.cc

@@ -296,6 +296,10 @@ class ExtensionsMenuViewBrowserTest : public ExtensionsToolbarBrowserTest {
 
     // Removing the last extension. All actions now have the same state.
     RemoveExtension(method, extensions()[1]->id());
+
+    // Container should remain visible during the removal animation.
+    EXPECT_TRUE(GetExtensionsToolbarContainer()->IsDrawn());
+    views::test::WaitForAnimatingLayoutManager(GetExtensionsToolbarContainer());
     EXPECT_EQ(expected_visibility, GetExtensionsToolbarContainer()->IsDrawn());
   }
 

chrome/browser/ui/views/extensions/extensions_toolbar_button.cc

@@ -29,7 +29,7 @@ ExtensionsToolbarButton::ExtensionsToolbarButton(
   std::unique_ptr<views::MenuButtonController> menu_button_controller =
       std::make_unique<views::MenuButtonController>(
           this,
-          base::BindRepeating(&ExtensionsToolbarButton::ButtonPressed,
+          base::BindRepeating(&ExtensionsToolbarButton::ShowExtensionsMenu,
                               base::Unretained(this)),
           std::make_unique<views::Button::DefaultButtonControllerDelegate>(
               this));
@@ -95,22 +95,28 @@ void ExtensionsToolbarButton::UpdateIcon() {
 void ExtensionsToolbarButton::OnWidgetDestroying(views::Widget* widget) {
   widget->RemoveObserver(this);
   pressed_lock_.reset();
+  extensions_container_->OnMenuClosed();
 }
 
-int ExtensionsToolbarButton::GetIconSize() const {
-  const bool touch_ui = ui::TouchUiController::Get()->touch_ui();
-  return (touch_ui && !browser_->app_controller()) ? kDefaultTouchableIconSize
-                                                   : kDefaultIconSize;
-}
-
-void ExtensionsToolbarButton::ButtonPressed() {
+void ExtensionsToolbarButton::ShowExtensionsMenu() {
   if (ExtensionsMenuView::IsShowing()) {
     ExtensionsMenuView::Hide();
     return;
   }
   pressed_lock_ = menu_button_controller_->TakeLock();
+  extensions_container_->OnMenuOpening();
   base::RecordAction(base::UserMetricsAction("Extensions.Toolbar.MenuOpened"));
   ExtensionsMenuView::ShowBubble(this, browser_, extensions_container_,
                                  extensions_container_->CanShowIconInToolbar())
       ->AddObserver(this);
 }
+
+bool ExtensionsToolbarButton::IsExtensionsMenuShowing() const {
+  return pressed_lock_.get();
+}
+
+int ExtensionsToolbarButton::GetIconSize() const {
+  const bool touch_ui = ui::TouchUiController::Get()->touch_ui();
+  return (touch_ui && !browser_->app_controller()) ? kDefaultTouchableIconSize
+                                                   : kDefaultIconSize;
+}

chrome/browser/ui/views/extensions/extensions_toolbar_button.h

@@ -26,6 +26,12 @@ class ExtensionsToolbarButton : public ToolbarButton,
   ExtensionsToolbarButton& operator=(const ExtensionsToolbarButton&) = delete;
   ~ExtensionsToolbarButton() override;
 
+  // Activate the Extensions menu. If the ExtensionsToolbarContainer is in
+  // kAutoHide mode this will cause it to show.
+  void ShowExtensionsMenu();
+
+  bool IsExtensionsMenuShowing() const;
+
   // ToolbarButton:
   gfx::Size CalculatePreferredSize() const override;
   gfx::Size GetMinimumSize() const override;
@@ -39,8 +45,6 @@ class ExtensionsToolbarButton : public ToolbarButton,
  private:
   int GetIconSize() const;
 
-  void ButtonPressed();
-
   // A lock to keep the button pressed when a popup is visible.
   std::unique_ptr<views::MenuButtonController::PressedLock> pressed_lock_;
 

chrome/browser/ui/views/extensions/extensions_toolbar_container.cc

@@ -64,8 +64,9 @@ ExtensionsToolbarContainer::ExtensionsToolbarContainer(Browser* browser,
                                       views::FlexSpecification());
       break;
     case DisplayMode::kCompact:
-      // In compact mode, the menu icon can be hidden but has the highest
-      // priority.
+    case DisplayMode::kAutoHide:
+      // In compact/auto hide mode, the menu icon can be hidden but has the
+      // highest priority.
       extensions_button_->SetProperty(
           views::kFlexBehaviorKey, hide_icon_flex_specification.WithOrder(1));
       break;
@@ -174,8 +175,9 @@ void ExtensionsToolbarContainer::UpdateIconVisibility(
                                  views::FlexSpecification());
         break;
       case DisplayMode::kCompact:
-        // In compact mode, the icon can still drop out, but receives precedence
-        // over other actions.
+      case DisplayMode::kAutoHide:
+        // In compact/auto hide mode, the icon can still drop out, but receives
+        // precedence over other actions.
         action_view->SetProperty(
             views::kFlexBehaviorKey,
             views::FlexSpecification(
@@ -291,6 +293,7 @@ void ExtensionsToolbarContainer::UndoPopOut() {
   ToolbarActionViewController* const popped_out_action = popped_out_action_;
   popped_out_action_ = nullptr;
   UpdateIconVisibility(popped_out_action->GetId());
+  UpdateContainerVisibilityAfterAnimation();
 }
 
 void ExtensionsToolbarContainer::SetPopupOwner(
@@ -299,12 +302,17 @@ void ExtensionsToolbarContainer::SetPopupOwner(
   // never unsetting one when one wasn't set.
   DCHECK((popup_owner_ != nullptr) ^ (popup_owner != nullptr));
   popup_owner_ = popup_owner;
+  if (popup_owner_)
+    UpdateContainerVisibility();
+  else
+    UpdateContainerVisibilityAfterAnimation();
 }
 
 void ExtensionsToolbarContainer::HideActivePopup() {
   if (popup_owner_)
     popup_owner_->HidePopup();
   DCHECK(!popup_owner_);
+  UpdateContainerVisibilityAfterAnimation();
 }
 
 bool ExtensionsToolbarContainer::CloseOverflowMenuIfOpen() {
@@ -324,6 +332,7 @@ void ExtensionsToolbarContainer::PopOutAction(
   popped_out_action_ = action;
   UpdateIconVisibility(action->GetId());
   animating_layout_manager()->PostOrQueueAction(closure);
+  UpdateContainerVisibility();
 }
 
 bool ExtensionsToolbarContainer::ShowToolbarActionPopupForAPICall(
@@ -400,7 +409,7 @@ void ExtensionsToolbarContainer::OnToolbarActionRemoved(
   RemoveChildViewT(GetViewForId(action_id));
   icons_.erase(action_id);
 
-  UpdateContainerVisibility();
+  UpdateContainerVisibilityAfterAnimation();
 }
 
 void ExtensionsToolbarContainer::OnToolbarActionMoved(
@@ -666,7 +675,53 @@ void ExtensionsToolbarContainer::SetExtensionIconVisibility(
 }
 
 void ExtensionsToolbarContainer::UpdateContainerVisibility() {
-  // The container (and extensions-menu button) should be visible if we have at
-  // least one extension.
-  SetVisible(!actions_.empty());
+  bool was_visible = GetVisible();
+  SetVisible(ShouldContainerBeVisible());
+
+  // Layout animation does not handle host view visibility changing; requires
+  // resetting.
+  if (was_visible != GetVisible())
+    animating_layout_manager()->ResetLayout();
+}
+
+bool ExtensionsToolbarContainer::ShouldContainerBeVisible() const {
+  // The container (and extensions-menu button) should not be visible if we have
+  // no extensions.
+  if (actions_.empty())
+    return false;
+
+  // All other display modes are constantly visible.
+  if (display_mode_ != DisplayMode::kAutoHide)
+    return true;
+
+  if (animating_layout_manager()->is_animating())
+    return true;
+
+  // Is menu showing.
+  if (extensions_button_->IsExtensionsMenuShowing())
+    return true;
+
+  // Is extension pop out is showing.
+  if (popped_out_action_)
+    return true;
+
+  // Is extension pop up showing.
+  if (popup_owner_)
+    return true;
+
+  return false;
+}
+
+void ExtensionsToolbarContainer::UpdateContainerVisibilityAfterAnimation() {
+  animating_layout_manager()->PostOrQueueAction(
+      base::BindOnce(&ExtensionsToolbarContainer::UpdateContainerVisibility,
+                     weak_ptr_factory_.GetWeakPtr()));
+}
+
+void ExtensionsToolbarContainer::OnMenuOpening() {
+  UpdateContainerVisibility();
+}
+
+void ExtensionsToolbarContainer::OnMenuClosed() {
+  UpdateContainerVisibility();
 }

chrome/browser/ui/views/extensions/extensions_toolbar_container.h

@@ -50,9 +50,14 @@ class ExtensionsToolbarContainer : public ToolbarIconContainerView,
     // always enough space to show at least two icons.
     kNormal,
     // In compact mode, one or both of the menu icon and popped-out action may
-    // be hidden. Compact mode is used in smaller windows (e.g. webapps) where
+    // be hidden. Compact mode is used in smaller windows (e.g. web apps) where
     // there may not be enough space to display the buttons.
     kCompact,
+    // In auto hide mode the menu icon is hidden until
+    // extensions_button()->ShowExtensionsMenu() is called by the embedder. This
+    // is used for windows that want to minimize the number of icons in their
+    // toolbar (e.g. web apps).
+    kAutoHide,
   };
 
   explicit ExtensionsToolbarContainer(
@@ -140,6 +145,8 @@ class ExtensionsToolbarContainer : public ToolbarIconContainerView,
                            const gfx::Point& p) override;
 
  private:
+  friend class ExtensionsToolbarButton;
+
   // A struct representing the position and action being dragged.
   struct DropInfo;
 
@@ -187,10 +194,23 @@ class ExtensionsToolbarContainer : public ToolbarIconContainerView,
   void SetExtensionIconVisibility(ToolbarActionsModel::ActionId id,
                                   bool visible);
 
-  // Calls SetVisible to make sure that the container is showing only when there
-  // are extensions available.
+  // Calls SetVisible() with ShouldContainerBeVisible().
   void UpdateContainerVisibility();
 
+  // Returns whether we should be showing the container e.g. not if there are no
+  // extensions installed or we are inactive in auto hide mode.
+  bool ShouldContainerBeVisible() const;
+
+  // Queues up a call to UpdateContainerVisibility() for when the current layout
+  // animation ends.
+  void UpdateContainerVisibilityAfterAnimation();
+
+  // Event handler for when the extensions menu is opened.
+  void OnMenuOpening();
+
+  // Event handler for when the extensions menu is closed.
+  void OnMenuClosed();
+
   // TabStripModelObserver:
   void OnTabStripModelChanged(
       TabStripModel* tab_strip_model,

chrome/browser/ui/views/frame/opaque_browser_frame_view_browsertest.cc

@@ -12,6 +12,7 @@
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/opaque_browser_frame_view_layout.h"
 #include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_view.h"
+#include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_toolbar_button_container.h"
 #include "chrome/browser/ui/web_applications/test/web_app_browsertest_util.h"
 #include "chrome/browser/web_applications/components/web_application_info.h"
 #include "chrome/test/base/in_process_browser_test.h"

chrome/browser/ui/views/location_bar/custom_tab_bar_view.cc

@@ -229,8 +229,9 @@ CustomTabBarView::CustomTabBarView(BrowserView* browser_view,
 #if BUILDFLAG(IS_CHROMEOS_ASH)
   if (browser_->is_type_custom_tab()) {
     web_app_menu_button_ = AddChildView(std::make_unique<WebAppMenuButton>(
-        browser_view, l10n_util::GetStringUTF16(
-                          IDS_CUSTOM_TABS_ACTION_MENU_ACCESSIBLE_NAME)));
+        browser_view, /*model_delegate=*/nullptr,
+        l10n_util::GetStringUTF16(
+            IDS_CUSTOM_TABS_ACTION_MENU_ACCESSIBLE_NAME)));
 
     // Remove the vertical portion of the interior margin here to avoid
     // increasing the height of the toolbar when |web_app_menu_button_| is drawn

chrome/browser/ui/views/toolbar/toolbar_icon_container_view.h

@@ -58,6 +58,11 @@ class ToolbarIconContainerView : public views::View,
     return static_cast<views::AnimatingLayoutManager*>(GetLayoutManager());
   }
 
+  const views::AnimatingLayoutManager* animating_layout_manager() const {
+    return static_cast<const views::AnimatingLayoutManager*>(
+        GetLayoutManager());
+  }
+
   // Provides access to the flex layout in the animating layout manager.
   views::FlexLayout* target_layout_manager() {
     return static_cast<views::FlexLayout*>(

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_browsertest.cc

@@ -5,12 +5,17 @@
 #include <cmath>
 
 #include "base/optional.h"
+#include "base/path_service.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
+#include "chrome/browser/extensions/chrome_test_extension_loader.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
+#include "chrome/browser/ui/views/extensions/extensions_menu_view.h"
+#include "chrome/browser/ui/views/extensions/extensions_toolbar_button.h"
+#include "chrome/browser/ui/views/extensions/extensions_toolbar_container.h"
 #include "chrome/browser/ui/views/frame/app_menu_button.h"
 #include "chrome/browser/ui/views/frame/browser_non_client_frame_view.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
@@ -18,6 +23,11 @@
 #include "chrome/browser/ui/views/page_action/page_action_icon_controller.h"
 #include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_test_helper.h"
 #include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_view.h"
+#include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_navigation_button_container.h"
+#include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_toolbar_button_container.h"
+#include "chrome/browser/ui/web_applications/web_app_menu_model.h"
+#include "chrome/common/chrome_features.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
@@ -26,6 +36,7 @@
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/public/test/theme_change_waiter.h"
+#include "extensions/test/test_extension_dir.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/size.h"
@@ -50,6 +61,22 @@ T* GetLastVisible(const std::vector<T*>& views) {
   return visible;
 }
 
+void LoadTestPopUpExtension(Profile* profile) {
+  extensions::TestExtensionDir test_extension_dir;
+  test_extension_dir.WriteManifest(
+      R"({
+          "name": "Pop up extension",
+          "version": "1.0",
+          "manifest_version": 2,
+          "browser_action": {
+            "default_popup": "popup.html"
+          }
+         })");
+  test_extension_dir.WriteFile(FILE_PATH_LITERAL("popup.html"), "");
+  extensions::ChromeTestExtensionLoader(profile).LoadExtension(
+      test_extension_dir.UnpackedPath());
+}
+
 }  // namespace
 
 class WebAppFrameToolbarBrowserTest : public InProcessBrowserTest {
@@ -79,7 +106,7 @@ IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest, SpaceConstrained) {
   const GURL app_url("https://test.org");
   helper()->InstallAndLaunchWebApp(browser(), app_url);
 
-  views::View* const toolbar_left_container =
+  WebAppNavigationButtonContainer* const toolbar_left_container =
       helper()->web_app_frame_toolbar()->GetLeftContainerForTesting();
   EXPECT_EQ(toolbar_left_container->parent(),
             helper()->web_app_frame_toolbar());
@@ -92,7 +119,7 @@ IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest, SpaceConstrained) {
   EXPECT_EQ(window_title->parent(), helper()->frame_view());
 #endif
 
-  views::View* const toolbar_right_container =
+  WebAppToolbarButtonContainer* const toolbar_right_container =
       helper()->web_app_frame_toolbar()->GetRightContainerForTesting();
   EXPECT_EQ(toolbar_right_container->parent(),
             helper()->web_app_frame_toolbar());
@@ -226,9 +253,9 @@ IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest, TitleHover) {
   const GURL app_url("https://test.org");
   helper()->InstallAndLaunchWebApp(browser(), app_url);
 
-  views::View* const toolbar_left_container =
+  WebAppNavigationButtonContainer* const toolbar_left_container =
       helper()->web_app_frame_toolbar()->GetLeftContainerForTesting();
-  views::View* const toolbar_right_container =
+  WebAppToolbarButtonContainer* const toolbar_right_container =
       helper()->web_app_frame_toolbar()->GetRightContainerForTesting();
 
   auto* const window_title = static_cast<views::Label*>(
@@ -271,3 +298,82 @@ IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest, TitleHover) {
       helper()->frame_view()->GetTooltipHandlerForPoint(window_title->origin()),
       window_title);
 }
+
+class WebAppFrameToolbarBrowserTest_ElidedExtensionsMenu
+    : public WebAppFrameToolbarBrowserTest {
+ public:
+  WebAppFrameToolbarBrowserTest_ElidedExtensionsMenu() {
+    scoped_feature_list_.InitAndEnableFeature(
+        features::kDesktopPWAsElidedExtensionsMenu);
+  }
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest_ElidedExtensionsMenu,
+                       Test) {
+  LoadTestPopUpExtension(browser()->profile());
+  helper()->InstallAndLaunchWebApp(browser(), GURL("https://test.org"));
+
+  WebAppToolbarButtonContainer* toolbar_button_container =
+      helper()->web_app_frame_toolbar()->GetRightContainerForTesting();
+
+  // There should be no visible Extensions icon.
+  EXPECT_FALSE(toolbar_button_container
+                   ->extensions_container()
+
+                   ->GetVisible());
+
+  // There should be a menu entry for opening the Extensions menu.
+  auto app_menu_model = std::make_unique<WebAppMenuModel>(
+      /*provider=*/nullptr, helper()->app_browser(),
+      /*delegate=*/toolbar_button_container);
+  app_menu_model->Init();
+  ui::MenuModel* model = app_menu_model.get();
+  int index = -1;
+  const bool found = app_menu_model->GetModelAndIndexForCommandId(
+      WebAppMenuModel::kExtensionsMenuCommandId, &model, &index);
+  EXPECT_TRUE(found);
+  EXPECT_TRUE(model->IsEnabledAt(index));
+
+  app_menu_model->ExecuteCommand(WebAppMenuModel::kExtensionsMenuCommandId,
+                                 /*event_flags=*/0);
+
+  // Extensions icon and menu should be visible.
+  EXPECT_TRUE(toolbar_button_container->extensions_container()->GetVisible());
+  EXPECT_TRUE(ExtensionsMenuView::IsShowing());
+}
+
+class WebAppFrameToolbarBrowserTest_NoElidedExtensionsMenu
+    : public WebAppFrameToolbarBrowserTest {
+ public:
+  WebAppFrameToolbarBrowserTest_NoElidedExtensionsMenu() {
+    scoped_feature_list_.InitAndDisableFeature(
+        features::kDesktopPWAsElidedExtensionsMenu);
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+IN_PROC_BROWSER_TEST_F(WebAppFrameToolbarBrowserTest_NoElidedExtensionsMenu,
+                       Test) {
+  LoadTestPopUpExtension(browser()->profile());
+  helper()->InstallAndLaunchWebApp(browser(), GURL("https://test.org"));
+
+  WebAppToolbarButtonContainer* toolbar_button_container =
+      helper()->web_app_frame_toolbar()->GetRightContainerForTesting();
+
+  // Extensions icon should be present.
+  EXPECT_TRUE(toolbar_button_container->extensions_container()->GetVisible());
+
+  // There should be no menu entry for opening the Extensions menu.
+  auto app_menu_model = std::make_unique<WebAppMenuModel>(
+      /*provider=*/nullptr, helper()->app_browser(),
+      /*delegate=*/toolbar_button_container);
+  app_menu_model->Init();
+  ui::MenuModel* model = app_menu_model.get();
+  int index = -1;
+  const bool found = app_menu_model->GetModelAndIndexForCommandId(
+      WebAppMenuModel::kExtensionsMenuCommandId, &model, &index);
+  EXPECT_FALSE(found);
+}

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_view.cc

@@ -223,14 +223,6 @@ ReloadButton* WebAppFrameToolbarView::GetReloadButton() {
   return left_container_ ? left_container_->reload_button() : nullptr;
 }
 
-views::View* WebAppFrameToolbarView::GetLeftContainerForTesting() {
-  return left_container_;
-}
-
-views::View* WebAppFrameToolbarView::GetRightContainerForTesting() {
-  return right_container_;
-}
-
 PageActionIconController*
 WebAppFrameToolbarView::GetPageActionIconControllerForTesting() {
   return right_container_->page_action_icon_controller();

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_frame_toolbar_view.h

@@ -70,8 +70,12 @@ class WebAppFrameToolbarView : public views::AccessiblePaneView,
   ToolbarButton* GetBackButton() override;
   ReloadButton* GetReloadButton() override;
 
-  views::View* GetLeftContainerForTesting();
-  views::View* GetRightContainerForTesting();
+  WebAppNavigationButtonContainer* GetLeftContainerForTesting() {
+    return left_container_;
+  }
+  WebAppToolbarButtonContainer* GetRightContainerForTesting() {
+    return right_container_;
+  }
   PageActionIconController* GetPageActionIconControllerForTesting();
 
  protected:

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_menu_button.cc

@@ -27,10 +27,12 @@
 #include "ui/views/window/hit_test_utils.h"
 
 WebAppMenuButton::WebAppMenuButton(BrowserView* browser_view,
+                                   WebAppMenuModel::Delegate* model_delegate,
                                    base::string16 accessible_name)
     : AppMenuButton(base::BindRepeating(&WebAppMenuButton::ButtonPressed,
                                         base::Unretained(this))),
-      browser_view_(browser_view) {
+      browser_view_(browser_view),
+      model_delegate_(model_delegate) {
   views::SetHitTestComponent(this, static_cast<int>(HTMENU));
 
   SetInkDropMode(InkDropMode::ON);
@@ -77,7 +79,9 @@ void WebAppMenuButton::StartHighlightAnimation() {
 
 void WebAppMenuButton::ButtonPressed(const ui::Event& event) {
   Browser* browser = browser_view_->browser();
-  RunMenu(std::make_unique<WebAppMenuModel>(browser_view_, browser), browser,
+  RunMenu(std::make_unique<WebAppMenuModel>(browser_view_, browser,
+                                            model_delegate_),
+          browser,
           event.IsKeyEvent() ? views::MenuRunner::SHOULD_SHOW_MNEMONICS
                              : views::MenuRunner::NO_FLAGS,
           false);

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_menu_button.h

@@ -8,6 +8,7 @@
 #include "base/strings/string16.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/ui/views/frame/app_menu_button.h"
+#include "chrome/browser/ui/web_applications/web_app_menu_model.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/color_palette.h"
 
@@ -18,6 +19,7 @@ class WebAppMenuButton : public AppMenuButton {
  public:
   static int GetMenuButtonSizeForBrowser(Browser* browser);
   explicit WebAppMenuButton(BrowserView* browser_view,
+                            WebAppMenuModel::Delegate* model_delegate,
                             base::string16 accessible_name = base::string16());
   ~WebAppMenuButton() override;
 
@@ -44,6 +46,8 @@ class WebAppMenuButton : public AppMenuButton {
   // The containing browser view.
   BrowserView* browser_view_;
 
+  WebAppMenuModel::Delegate* model_delegate_;
+
   SkColor ink_drop_color_ = gfx::kPlaceholderColor;
 
   base::OneShotTimer highlight_off_timer_;

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_toolbar_button_container.cc

@@ -9,6 +9,7 @@
 #include "chrome/browser/ui/browser_content_setting_bubble_model_delegate.h"
 #include "chrome/browser/ui/ui_features.h"
 #include "chrome/browser/ui/view_ids.h"
+#include "chrome/browser/ui/views/extensions/extensions_toolbar_button.h"
 #include "chrome/browser/ui/views/extensions/extensions_toolbar_container.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/toolbar_button_provider.h"
@@ -19,6 +20,7 @@
 #include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_menu_button.h"
 #include "chrome/browser/ui/views/web_apps/frame_toolbar/web_app_origin_text.h"
 #include "chrome/browser/ui/web_applications/system_web_app_ui_utils.h"
+#include "chrome/common/chrome_features.h"
 #include "ui/base/hit_test.h"
 #include "ui/views/layout/flex_layout.h"
 #include "ui/views/window/hit_test_utils.h"
@@ -104,11 +106,16 @@ WebAppToolbarButtonContainer::WebAppToolbarButtonContainer(
     // for example, the menu button or other toolbar buttons, and pinned
     // extensions should hide before other toolbar buttons.
     constexpr int kLowPriorityFlexOrder = 2;
+    // TODO(https://crbug.com/1155421): Fix menu button misalignment when
+    // kHiddenByDefault is set for the Extensions toolbar.
+    auto display_mode =
+        base::FeatureList::IsEnabled(features::kDesktopPWAsElidedExtensionsMenu)
+            ? ExtensionsToolbarContainer::DisplayMode::kAutoHide
+            : ExtensionsToolbarContainer::DisplayMode::kCompact;
     if (base::FeatureList::IsEnabled(features::kExtensionsToolbarMenu)) {
       extensions_container_ =
           AddChildView(std::make_unique<ExtensionsToolbarContainer>(
-              browser_view_->browser(),
-              ExtensionsToolbarContainer::DisplayMode::kCompact));
+              browser_view_->browser(), display_mode));
       extensions_container_->SetProperty(
           views::kFlexBehaviorKey,
           views::FlexSpecification(
@@ -133,7 +140,7 @@ WebAppToolbarButtonContainer::WebAppToolbarButtonContainer(
 
   if (app_controller->HasTitlebarMenuButton()) {
     web_app_menu_button_ =
-        AddChildView(std::make_unique<WebAppMenuButton>(browser_view_));
+        AddChildView(std::make_unique<WebAppMenuButton>(browser_view_, this));
     web_app_menu_button_->SetID(VIEW_ID_APP_MENU);
     const bool is_browser_focus_mode =
         browser_view_->browser()->is_focus_mode();
@@ -349,6 +356,12 @@ WebAppToolbarButtonContainer::GetWebContentsForPageActionIconView() {
   return browser_view_->GetActiveWebContents();
 }
 
+// WebAppMenuModel::Delegate:
+void WebAppToolbarButtonContainer::OpenExtensionMenu() {
+  extensions_container()->extensions_button()->ShowExtensionsMenu();
+}
+
+// views::WidgetObserver:
 void WebAppToolbarButtonContainer::OnWidgetVisibilityChanged(
     views::Widget* widget,
     bool visible) {

chrome/browser/ui/views/web_apps/frame_toolbar/web_app_toolbar_button_container.h

@@ -12,6 +12,7 @@
 #include "chrome/browser/ui/views/page_action/page_action_icon_container.h"
 #include "chrome/browser/ui/views/page_action/page_action_icon_view.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
+#include "chrome/browser/ui/web_applications/web_app_menu_model.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
@@ -31,6 +32,7 @@ class WebAppToolbarButtonContainer : public views::View,
                                      public ImmersiveModeController::Observer,
                                      public PageActionIconView::Delegate,
                                      public PageActionIconContainer,
+                                     public WebAppMenuModel::Delegate,
                                      public views::WidgetObserver {
  public:
   // Timing parameters for the origin fade animation.
@@ -133,6 +135,9 @@ class WebAppToolbarButtonContainer : public views::View,
   // PageActionIconView::Delegate:
   content::WebContents* GetWebContentsForPageActionIconView() override;
 
+  // WebAppMenuModel::Delegate:
+  void OpenExtensionMenu() override;
+
   // views::WidgetObserver:
   void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override;
 

chrome/browser/ui/views/web_apps/web_app_integration_browsertest.cc

@@ -217,7 +217,7 @@ class WebAppIntegrationBrowserTest
     extensions::ScopedTestDialogAutoConfirm auto_confirm(
         extensions::ScopedTestDialogAutoConfirm::ACCEPT);
     auto app_menu_model =
-        std::make_unique<WebAppMenuModel>(nullptr, app_browser_);
+        std::make_unique<WebAppMenuModel>(nullptr, app_browser_, nullptr);
     app_menu_model->Init();
     ui::MenuModel* model = app_menu_model.get();
     int index = -1;

chrome/browser/ui/web_applications/web_app_browsertest.cc

@@ -690,7 +690,8 @@ IN_PROC_BROWSER_TEST_F(WebAppBrowserTest, NoTabSelectedMenuCrash) {
   Browser* const app_browser = LaunchWebAppBrowserAndWait(app_id);
 
   app_browser->tab_strip_model()->CloseAllTabs();
-  auto app_menu_model = std::make_unique<WebAppMenuModel>(nullptr, app_browser);
+  auto app_menu_model = std::make_unique<WebAppMenuModel>(
+      /*provider=*/nullptr, app_browser, /*delegate=*/nullptr);
   app_menu_model->Init();
 }
 
@@ -700,7 +701,8 @@ IN_PROC_BROWSER_TEST_F(WebAppBrowserTest, UninstallMenuOption) {
   const AppId app_id = InstallPWA(app_url);
   Browser* const app_browser = LaunchWebAppBrowserAndWait(app_id);
 
-  auto app_menu_model = std::make_unique<WebAppMenuModel>(nullptr, app_browser);
+  auto app_menu_model = std::make_unique<WebAppMenuModel>(
+      /*provider=*/nullptr, app_browser, /*delegate=*/nullptr);
   app_menu_model->Init();
   ui::MenuModel* model = app_menu_model.get();
   int index = -1;

chrome/browser/ui/web_applications/web_app_menu_model.cc

@@ -4,6 +4,7 @@
 
 #include "chrome/browser/ui/web_applications/web_app_menu_model.h"
 
+#include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/chromeos_buildflags.h"
@@ -12,6 +13,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/web_applications/app_browser_controller.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/strings/grit/components_strings.h"
@@ -26,25 +28,39 @@
 #endif
 
 constexpr int WebAppMenuModel::kUninstallAppCommandId;
+constexpr int WebAppMenuModel::kExtensionsMenuCommandId;
 
 WebAppMenuModel::WebAppMenuModel(ui::AcceleratorProvider* provider,
-                                 Browser* browser)
-    : AppMenuModel(provider, browser) {}
+                                 Browser* browser,
+                                 Delegate* delegate)
+    : AppMenuModel(provider, browser), delegate_(delegate) {}
 
 WebAppMenuModel::~WebAppMenuModel() {}
 
 bool WebAppMenuModel::IsCommandIdEnabled(int command_id) const {
-  return command_id == kUninstallAppCommandId
-             ? browser()->app_controller()->CanUninstall()
-             : AppMenuModel::IsCommandIdEnabled(command_id);
+  switch (command_id) {
+    case kUninstallAppCommandId:
+      return browser()->app_controller()->CanUninstall();
+    case kExtensionsMenuCommandId:
+      return delegate_ && base::FeatureList::IsEnabled(
+                              features::kDesktopPWAsElidedExtensionsMenu);
+    default:
+      return AppMenuModel::IsCommandIdEnabled(command_id);
+  }
 }
 
 void WebAppMenuModel::ExecuteCommand(int command_id, int event_flags) {
-  if (command_id == kUninstallAppCommandId) {
-    LogMenuAction(MENU_ACTION_UNINSTALL_APP);
-    browser()->app_controller()->Uninstall();
-  } else {
-    AppMenuModel::ExecuteCommand(command_id, event_flags);
+  switch (command_id) {
+    case kUninstallAppCommandId:
+      LogMenuAction(MENU_ACTION_UNINSTALL_APP);
+      browser()->app_controller()->Uninstall();
+      break;
+    case kExtensionsMenuCommandId:
+      delegate_->OpenExtensionMenu();
+      break;
+    default:
+      AppMenuModel::ExecuteCommand(command_id, event_flags);
+      break;
   }
 }
 
@@ -68,6 +84,9 @@ void WebAppMenuModel::Build() {
                    browser()->location_bar_model()->GetVectorIcon()));
 
   AddSeparator(ui::NORMAL_SEPARATOR);
+
+  if (IsCommandIdEnabled(kExtensionsMenuCommandId))
+    AddItemWithStringId(kExtensionsMenuCommandId, IDS_SHOW_EXTENSIONS);
   AddItemWithStringId(IDC_COPY_URL, IDS_COPY_URL);
   AddItemWithStringId(IDC_OPEN_IN_CHROME, IDS_OPEN_IN_CHROME);
 

chrome/browser/ui/web_applications/web_app_menu_model.h

@@ -13,9 +13,17 @@ class AssignToDesksMenuModel;
 // Menu model for the menu button in a web app browser window.
 class WebAppMenuModel : public AppMenuModel {
  public:
+  class Delegate {
+   public:
+    virtual void OpenExtensionMenu() = 0;
+  };
+
   static constexpr int kUninstallAppCommandId = 1;
+  static constexpr int kExtensionsMenuCommandId = 2;
 
-  WebAppMenuModel(ui::AcceleratorProvider* provider, Browser* browser);
+  WebAppMenuModel(ui::AcceleratorProvider* provider,
+                  Browser* browser,
+                  Delegate* delegate);
   WebAppMenuModel(const WebAppMenuModel&) = delete;
   WebAppMenuModel& operator=(const WebAppMenuModel&) = delete;
   ~WebAppMenuModel() override;
@@ -30,6 +38,8 @@ class WebAppMenuModel : public AppMenuModel {
   void LogMenuAction(AppMenuAction action_id) override;
 
  private:
+  Delegate* delegate_ = nullptr;
+
 #if BUILDFLAG(IS_CHROMEOS_ASH)
   std::unique_ptr<AssignToDesksMenuModel> assign_to_desks_submenu_;
 #endif