ash: disinherit HUDDisplayView from WidgetDelegateView

Instead, have HUDDisplayView::Toggle explicitly create and configure
a WidgetDelegate.

This change also adds callbacks for widget initialization steps to
WidgetDelegate.

Bug: 1075649
Change-Id: Ia48270e7d7431abbfdf0c6d58988d4846a1ed8c2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2511409Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Elly Fong-Jones <ellyjones@chromium.org>
Cr-Commit-Position: refs/heads/master@{#823588}

ash/hud_display/hud_display.cc

@@ -26,6 +26,7 @@
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/metadata/metadata_impl_macros.h"
 #include "ui/views/widget/widget.h"
+#include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 namespace hud_display {
@@ -70,12 +71,27 @@ class HTClientView : public views::ClientView {
 BEGIN_METADATA(HTClientView, views::ClientView)
 END_METADATA
 
+std::unique_ptr<views::ClientView> MakeClientView(views::Widget* widget) {
+  auto view = std::make_unique<HUDDisplayView>();
+  auto* weak_view = view.get();
+  return std::make_unique<HTClientView>(weak_view, widget, view.release());
+}
+
+void InitializeFrameView(views::WidgetDelegate* delegate) {
+  auto* frame_view = delegate->GetWidget()->non_client_view()->frame_view();
+  // TODO(oshima): support component type with TYPE_WINDOW_FLAMELESS widget.
+  if (frame_view) {
+    frame_view->SetEnabled(false);
+    frame_view->SetVisible(false);
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // HUDDisplayView, public:
 
-BEGIN_METADATA(HUDDisplayView, views::WidgetDelegateView)
+BEGIN_METADATA(HUDDisplayView, views::View)
 END_METADATA
 
 // static
@@ -91,8 +107,14 @@ void HUDDisplayView::Toggle() {
     return;
   }
 
+  auto delegate = std::make_unique<views::WidgetDelegate>();
+  delegate->SetClientViewFactory(base::BindOnce(&MakeClientView));
+  delegate->RegisterWidgetInitializedCallback(
+      base::BindOnce(&InitializeFrameView, base::Unretained(delegate.get())));
+  delegate->SetOwnedByWidget(true);
+
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.delegate = new HUDDisplayView();
+  params.delegate = delegate.release();
   params.parent = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                       kShellWindowId_OverlayContainer);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
@@ -163,19 +185,6 @@ HUDDisplayView::~HUDDisplayView() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(ui_sequence_checker_);
 }
 
-views::ClientView* HUDDisplayView::CreateClientView(views::Widget* widget) {
-  return new HTClientView(this, widget, TransferOwnershipOfContentsView());
-}
-
-void HUDDisplayView::OnWidgetInitialized() {
-  auto* frame_view = GetWidget()->non_client_view()->frame_view();
-  // TODO(oshima): support component type with TYPE_WINDOW_FLAMELESS widget.
-  if (frame_view) {
-    frame_view->SetEnabled(false);
-    frame_view->SetVisible(false);
-  }
-}
-
 // There is only one button.
 void HUDDisplayView::OnSettingsToggle() {
   settings_view_->ToggleVisibility();

ash/hud_display/hud_display.h

@@ -7,7 +7,6 @@
 
 #include "base/sequence_checker.h"
 #include "ui/views/view.h"
-#include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 namespace hud_display {
@@ -18,7 +17,7 @@ class HUDHeaderView;
 class HUDSettingsView;
 
 // HUDDisplayView class can be used to display a system monitoring overview.
-class HUDDisplayView : public views::WidgetDelegateView {
+class HUDDisplayView : public views::View {
  public:
   METADATA_HEADER(HUDDisplayView);
 
@@ -28,10 +27,6 @@ class HUDDisplayView : public views::WidgetDelegateView {
 
   ~HUDDisplayView() override;
 
-  // WidgetDelegate:
-  views::ClientView* CreateClientView(views::Widget* widget) override;
-  void OnWidgetInitialized() override;
-
   // Destroys global instance.
   static void Destroy();
 

ui/views/widget/widget_delegate.cc

@@ -48,7 +48,9 @@ WidgetDelegate::Params::Params() = default;
 WidgetDelegate::Params::~Params() = default;
 
 WidgetDelegate::WidgetDelegate()
-    : client_view_factory_(
+    : widget_initializing_callbacks_(std::make_unique<ClosureVector>()),
+      widget_initialized_callbacks_(std::make_unique<ClosureVector>()),
+      client_view_factory_(
           base::BindOnce(&CreateDefaultClientView, base::Unretained(this))),
       non_client_frame_view_factory_(
           base::BindOnce(&CreateDefaultNonClientFrameView)),
@@ -184,10 +186,16 @@ bool WidgetDelegate::GetSavedWindowPlacement(
 
 void WidgetDelegate::WidgetInitializing(Widget* widget) {
   widget_ = widget;
+  for (auto&& callback : *widget_initializing_callbacks_)
+    std::move(callback).Run();
+  widget_initializing_callbacks_.reset();
   OnWidgetInitializing();
 }
 
 void WidgetDelegate::WidgetInitialized() {
+  for (auto&& callback : *widget_initialized_callbacks_)
+    std::move(callback).Run();
+  widget_initialized_callbacks_.reset();
   OnWidgetInitialized();
 }
 
@@ -362,6 +370,18 @@ void WidgetDelegate::SetHasWindowSizeControls(bool has_controls) {
   SetCanResize(has_controls);
 }
 
+void WidgetDelegate::RegisterWidgetInitializingCallback(
+    base::OnceClosure callback) {
+  DCHECK(widget_initializing_callbacks_);
+  widget_initializing_callbacks_->emplace_back(std::move(callback));
+}
+
+void WidgetDelegate::RegisterWidgetInitializedCallback(
+    base::OnceClosure callback) {
+  DCHECK(widget_initialized_callbacks_);
+  widget_initialized_callbacks_->emplace_back(std::move(callback));
+}
+
 void WidgetDelegate::RegisterWindowWillCloseCallback(
     base::OnceClosure callback) {
   window_will_close_callbacks_.emplace_back(std::move(callback));

ui/views/widget/widget_delegate.h

@@ -353,6 +353,8 @@ class VIEWS_EXPORT WidgetDelegate {
   // SetCanMinimize, and SetCanResize.
   void SetHasWindowSizeControls(bool has_controls);
 
+  void RegisterWidgetInitializingCallback(base::OnceClosure callback);
+  void RegisterWidgetInitializedCallback(base::OnceClosure callback);
   void RegisterWindowWillCloseCallback(base::OnceClosure callback);
   void RegisterWindowClosingCallback(base::OnceClosure callback);
   void RegisterDeleteDelegateCallback(base::OnceClosure callback);
@@ -381,6 +383,11 @@ class VIEWS_EXPORT WidgetDelegate {
   std::string internal_name() const { return params_.internal_name; }
 
  private:
+  // We're using a vector of OnceClosures instead of a OnceCallbackList because
+  // most of the clients of WidgetDelegate don't have a convenient place to
+  // store the CallbackLists' subscription objects.
+  using ClosureVector = std::vector<base::OnceClosure>;
+
   friend class Widget;
 
   void SetContentsViewImpl(View* contents);
@@ -400,9 +407,14 @@ class VIEWS_EXPORT WidgetDelegate {
   // Managed by Widget. Ensures |this| outlives its Widget.
   bool can_delete_this_ = true;
 
-  std::vector<base::OnceClosure> window_will_close_callbacks_;
-  std::vector<base::OnceClosure> window_closing_callbacks_;
-  std::vector<base::OnceClosure> delete_delegate_callbacks_;
+  // The first two are stored as unique_ptrs to make it easier to check in the
+  // registration methods whether a callback is being registered too late in the
+  // WidgetDelegate's lifecycle.
+  std::unique_ptr<ClosureVector> widget_initializing_callbacks_;
+  std::unique_ptr<ClosureVector> widget_initialized_callbacks_;
+  ClosureVector window_will_close_callbacks_;
+  ClosureVector window_closing_callbacks_;
+  ClosureVector delete_delegate_callbacks_;
 
   ClientViewFactory client_view_factory_;
   NonClientFrameViewFactory non_client_frame_view_factory_;