Adds support for AssistantOverlays.

AssistantOverlays are views which are added to AssistantContainerView's
client view. Because they are added at this level of the view hierarchy,
they paint to a higher level in the layer tree than direct children of
AssistantContainerView.

AssistantOverlays are intended to behave as pseudo-children of views in
the Assistant view hierarchy that need to paint to a high level, say to
draw over top of Assistant cards.

This CL adds a flag guarded AssistantNotificationOverlay which behaves
as a pseudo-child of AssistantMainView and will be used to support
in-Assistant notifications in Assistant.

Future overlays will include a shadow that is painted above suggestion
chips when the Assistant main stage can be scrolled (b:112669597).

Bug: b:118654460
Change-Id: I8e9a2c9748b4ecb0fad51c2f27722890d20d4ff3
Reviewed-on: https://chromium-review.googlesource.com/c/1440906
Commit-Queue: David Black <dmblack@google.com>
Reviewed-by: Xiaohui Chen <xiaohuic@chromium.org>
Cr-Commit-Position: refs/heads/master@{#628504}

ash/assistant/ui/BUILD.gn

@@ -38,6 +38,9 @@ component("ui") {
     "assistant_main_view.h",
     "assistant_mini_view.cc",
     "assistant_mini_view.h",
+    "assistant_notification_overlay.cc",
+    "assistant_notification_overlay.h",
+    "assistant_overlay.h",
     "assistant_view_delegate.h",
     "assistant_web_view.cc",
     "assistant_web_view.h",
@@ -87,6 +90,7 @@ component("ui") {
     "//ash/strings",
     "//base",
     "//chromeos/assistant:buildflags",
+    "//chromeos/services/assistant/public:feature_flags",
     "//chromeos/services/assistant/public/mojom",
     "//services/content/public/cpp",
     "//ui/aura",

ash/assistant/ui/DEPS

@@ -11,7 +11,7 @@ include_rules = [
   "+build/buildflag.h",
   "+cc/paint",
   "+chromeos/assistant",
-  "+chromeos/services/assistant/public/mojom",
+  "+chromeos/services/assistant/public",
   "+mojo/public/cpp",
   "+services/content/public",
   "+third_party/skia/include/core",

ash/assistant/ui/assistant_container_view.cc

@@ -5,11 +5,14 @@
 #include "ash/assistant/ui/assistant_container_view.h"
 
 #include <algorithm>
+#include <set>
+#include <vector>
 
 #include "ash/assistant/model/assistant_ui_model.h"
 #include "ash/assistant/ui/assistant_container_view_animator.h"
 #include "ash/assistant/ui/assistant_main_view.h"
 #include "ash/assistant/ui/assistant_mini_view.h"
+#include "ash/assistant/ui/assistant_overlay.h"
 #include "ash/assistant/ui/assistant_ui_constants.h"
 #include "ash/assistant/ui/assistant_view_delegate.h"
 #include "ash/assistant/ui/assistant_web_view.h"
@@ -26,6 +29,7 @@
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/layout/layout_manager.h"
 #include "ui/views/view.h"
+#include "ui/views/window/dialog_client_view.h"
 
 namespace ash {
 
@@ -37,6 +41,76 @@ constexpr SkColor kBackgroundColor = SK_ColorWHITE;
 // Window properties.
 DEFINE_UI_CLASS_PROPERTY_KEY(bool, kOnlyAllowMouseClickEvents, false);
 
+// AssistantContainerClientView ------------------------------------------------
+
+// AssistantContainerClientView is the client view for AssistantContainerView
+// which provides support for adding overlays to the Assistant view hierarchy.
+// Because overlays are added to the AssistantContainerView client view, they
+// paint to a higher level in the layer tree than do direct children of
+// AssistantContainerView. This allows AssistantMainView, for example, to
+// pseudo-parent overlays that draw over top of Assistant cards.
+class AssistantContainerClientView : public views::DialogClientView,
+                                     public views::ViewObserver {
+ public:
+  AssistantContainerClientView(views::Widget* widget,
+                               views::View* contents_view)
+      : views::DialogClientView(widget, contents_view) {}
+
+  ~AssistantContainerClientView() override = default;
+
+  // views::DialogClientView:
+  const char* GetClassName() const override {
+    return "AssistantContainerClientView";
+  }
+
+  void Layout() override {
+    views::DialogClientView::Layout();
+    for (AssistantOverlay* overlay : overlays_) {
+      AssistantOverlay::LayoutParams layout_params = overlay->GetLayoutParams();
+      gfx::Size preferred_size = overlay->GetPreferredSize();
+
+      int left = layout_params.margins.left();
+      int top = layout_params.margins.top();
+      int width = preferred_size.width();
+      int height = preferred_size.height();
+
+      // Gravity::kBottom.
+      using Gravity = AssistantOverlay::LayoutParams::Gravity;
+      if ((layout_params.gravity & Gravity::kBottom) != 0)
+        top = this->height() - height - layout_params.margins.bottom();
+
+      // Gravity::kCenterHorizontal.
+      if ((layout_params.gravity & Gravity::kCenterHorizontal) != 0)
+        left = (this->width() - width) / 2 - layout_params.margins.left();
+
+      overlay->SetBounds(left, top, width, height);
+    }
+  }
+
+  // views::ViewObserver:
+  void OnViewIsDeleting(views::View* view) override {
+    view->RemoveObserver(this);
+
+    // We need to keep |overlays_| in sync with the view hierarchy.
+    auto it = overlays_.find(static_cast<AssistantOverlay*>(view));
+    DCHECK(it != overlays_.end());
+    overlays_.erase(it);
+  }
+
+  void AddOverlays(std::vector<AssistantOverlay*> overlays) {
+    for (AssistantOverlay* overlay : overlays) {
+      overlays_.insert(overlay);
+      overlay->AddObserver(this);
+      AddChildView(overlay);
+    }
+  }
+
+ private:
+  std::set<AssistantOverlay*> overlays_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssistantContainerClientView);
+};
+
 // AssistantContainerEventTargeter ---------------------------------------------
 
 class AssistantContainerEventTargeter : public aura::WindowTargeter {
@@ -251,6 +325,14 @@ void AssistantContainerView::OnBeforeBubbleWidgetInit(
   params->keep_on_top = true;
 }
 
+views::ClientView* AssistantContainerView::CreateClientView(
+    views::Widget* widget) {
+  AssistantContainerClientView* client_view =
+      new AssistantContainerClientView(widget, GetContentsView());
+  client_view->AddOverlays(assistant_main_view_->GetOverlays());
+  return client_view;
+}
+
 void AssistantContainerView::Init() {
   SetLayoutManager(std::make_unique<AssistantContainerLayout>(delegate_));
 

ash/assistant/ui/assistant_container_view.h

@@ -50,6 +50,7 @@ class COMPONENT_EXPORT(ASSISTANT_UI) AssistantContainerView
   void SizeToContents() override;
   void OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
                                 views::Widget* widget) const override;
+  views::ClientView* CreateClientView(views::Widget* widget) override;
   void Init() override;
   void RequestFocus() override;
 

ash/assistant/ui/assistant_main_view.cc

@@ -5,10 +5,11 @@
 #include "ash/assistant/ui/assistant_main_view.h"
 
 #include <algorithm>
-#include <memory>
+#include <utility>
 
 #include "ash/assistant/model/assistant_interaction_model.h"
 #include "ash/assistant/model/assistant_ui_model.h"
+#include "ash/assistant/ui/assistant_notification_overlay.h"
 #include "ash/assistant/ui/assistant_ui_constants.h"
 #include "ash/assistant/ui/assistant_view_delegate.h"
 #include "ash/assistant/ui/caption_bar.h"
@@ -17,6 +18,7 @@
 #include "ash/assistant/util/animation_util.h"
 #include "ash/assistant/util/assistant_util.h"
 #include "base/time/time.h"
+#include "chromeos/services/assistant/public/features.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animator.h"
@@ -95,6 +97,14 @@ void AssistantMainView::OnBoundsChanged(const gfx::Rect& prev_bounds) {
   min_height_dip_ = std::max(min_height_dip_, height());
 }
 
+void AssistantMainView::VisibilityChanged(views::View* starting_from,
+                                          bool visible) {
+  // Overlays behave like children of AssistantMainView so they should only be
+  // visible while AssistantMainView is visible.
+  for (std::unique_ptr<AssistantOverlay>& overlay : overlays_)
+    overlay->SetVisible(visible);
+}
+
 void AssistantMainView::ChildPreferredSizeChanged(views::View* child) {
   PreferredSizeChanged();
 
@@ -118,6 +128,13 @@ views::View* AssistantMainView::FindFirstFocusableView() {
   return dialog_plate_->FindFirstFocusableView();
 }
 
+std::vector<AssistantOverlay*> AssistantMainView::GetOverlays() {
+  std::vector<AssistantOverlay*> overlays;
+  for (std::unique_ptr<AssistantOverlay>& overlay : overlays_)
+    overlays.push_back(overlay.get());
+  return overlays;
+}
+
 void AssistantMainView::InitLayout() {
   views::BoxLayout* layout_manager =
       SetLayoutManager(std::make_unique<views::BoxLayout>(
@@ -147,6 +164,14 @@ void AssistantMainView::InitLayout() {
   dialog_plate_->layer()->SetFillsBoundsOpaquely(false);
 
   AddChildView(dialog_plate_);
+
+  // Notification overlay.
+  if (chromeos::assistant::features::IsInAssistantNotificationsEnabled()) {
+    auto notification_overlay =
+        std::make_unique<AssistantNotificationOverlay>();
+    notification_overlay->set_owned_by_client();
+    overlays_.push_back(std::move(notification_overlay));
+  }
 }
 
 void AssistantMainView::OnUiVisibilityChanged(

ash/assistant/ui/assistant_main_view.h

@@ -5,6 +5,9 @@
 #ifndef ASH_ASSISTANT_UI_ASSISTANT_MAIN_VIEW_H_
 #define ASH_ASSISTANT_UI_ASSISTANT_MAIN_VIEW_H_
 
+#include <memory>
+#include <vector>
+
 #include "ash/assistant/model/assistant_ui_model_observer.h"
 #include "base/component_export.h"
 #include "base/macros.h"
@@ -13,6 +16,7 @@
 namespace ash {
 
 class AssistantMainStage;
+class AssistantOverlay;
 class AssistantViewDelegate;
 class CaptionBar;
 class DialogPlate;
@@ -31,6 +35,7 @@ class COMPONENT_EXPORT(ASSISTANT_UI) AssistantMainView
   void ChildPreferredSizeChanged(views::View* child) override;
   void ChildVisibilityChanged(views::View* child) override;
   void OnBoundsChanged(const gfx::Rect& prev_bounds) override;
+  void VisibilityChanged(views::View* starting_from, bool visible) override;
   void RequestFocus() override;
 
   // AssistantUiModelObserver:
@@ -43,6 +48,9 @@ class COMPONENT_EXPORT(ASSISTANT_UI) AssistantMainView
   // Returns the first focusable view or nullptr to defer to views::FocusSearch.
   views::View* FindFirstFocusableView();
 
+  // Returns the overlays that behave as pseudo-children of AssistantMainView.
+  std::vector<AssistantOverlay*> GetOverlays();
+
  private:
   void InitLayout();
 
@@ -52,6 +60,11 @@ class COMPONENT_EXPORT(ASSISTANT_UI) AssistantMainView
   DialogPlate* dialog_plate_;                       // Owned by view hierarchy.
   AssistantMainStage* main_stage_;                  // Owned by view hierarchy.
 
+  // Overlays behave as pseudo-children of AssistantMainView. They paint to a
+  // higher lever in the layer tree so they are visible over the top of
+  // Assistant cards.
+  std::vector<std::unique_ptr<AssistantOverlay>> overlays_;
+
   int min_height_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(AssistantMainView);

ash/assistant/ui/assistant_notification_overlay.cc

+// Copyright 2018 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/assistant/ui/assistant_notification_overlay.h"
+
+#include "ui/gfx/canvas.h"
+
+namespace ash {
+
+namespace {
+
+// Appearance.
+constexpr int kMarginBottomDip = 64;
+constexpr int kPreferredHeightDip = 60;
+constexpr int kPreferredWidthDip = 576;
+
+}  // namespace
+
+AssistantNotificationOverlay::AssistantNotificationOverlay() {
+  InitLayout();
+}
+
+AssistantNotificationOverlay::~AssistantNotificationOverlay() = default;
+
+const char* AssistantNotificationOverlay::GetClassName() const {
+  return "AssistantNotificationOverlay";
+}
+
+gfx::Size AssistantNotificationOverlay::CalculatePreferredSize() const {
+  return gfx::Size(kPreferredWidthDip, GetHeightForWidth(kPreferredWidthDip));
+}
+
+int AssistantNotificationOverlay::GetHeightForWidth(int width) const {
+  return kPreferredHeightDip;
+}
+
+AssistantOverlay::LayoutParams AssistantNotificationOverlay::GetLayoutParams()
+    const {
+  using Gravity = AssistantOverlay::LayoutParams::Gravity;
+  AssistantOverlay::LayoutParams layout_params;
+  layout_params.gravity = Gravity::kBottom | Gravity::kCenterHorizontal;
+  layout_params.margins = gfx::Insets(0, 0, kMarginBottomDip, 0);
+  return layout_params;
+}
+
+// TODO(dmblack): Remove when notification views have been implemented.
+void AssistantNotificationOverlay::OnPaintBackground(gfx::Canvas* canvas) {
+  canvas->DrawColor(0x20000000);
+}
+
+void AssistantNotificationOverlay::InitLayout() {
+  SetPaintToLayer();
+  layer()->SetFillsBoundsOpaquely(false);
+}
+
+};  // namespace ash

ash/assistant/ui/assistant_notification_overlay.h

+// Copyright 2018 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.
+
+#ifndef ASH_ASSISTANT_UI_ASSISTANT_NOTIFICATION_OVERLAY_H_
+#define ASH_ASSISTANT_UI_ASSISTANT_NOTIFICATION_OVERLAY_H_
+
+#include "ash/assistant/ui/assistant_overlay.h"
+#include "base/component_export.h"
+#include "base/macros.h"
+
+namespace ash {
+
+// AssistantNotificationOverlay is a pseudo-child of AssistantMainView which is
+// responsible for parenting in-Assistant notifications.
+class COMPONENT_EXPORT(ASSISTANT_UI) AssistantNotificationOverlay
+    : public AssistantOverlay {
+ public:
+  AssistantNotificationOverlay();
+  ~AssistantNotificationOverlay() override;
+
+  // AssistantOverlay:
+  const char* GetClassName() const override;
+  gfx::Size CalculatePreferredSize() const override;
+  int GetHeightForWidth(int width) const override;
+  LayoutParams GetLayoutParams() const override;
+  void OnPaintBackground(gfx::Canvas* canvas) override;
+
+ private:
+  void InitLayout();
+
+  DISALLOW_COPY_AND_ASSIGN(AssistantNotificationOverlay);
+};
+
+}  // namespace ash
+
+#endif  // ASH_ASSISTANT_UI_ASSISTANT_NOTIFICATION_OVERLAY_H_

ash/assistant/ui/assistant_overlay.h

+// Copyright 2018 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.
+
+#ifndef ASH_ASSISTANT_UI_ASSISTANT_OVERLAY_H_
+#define ASH_ASSISTANT_UI_ASSISTANT_OVERLAY_H_
+
+#include "base/component_export.h"
+#include "base/macros.h"
+#include "ui/views/view.h"
+
+namespace ash {
+
+// AssistantOverlays are children of AssistantContainerView's client view that
+// behave as pseudo-children of AssistantContainerView's own child views. This
+// allows children of AssistantContainerView to pseudo-parent views that paint
+// to a layer that is higher up in the layer tree than themselves. In the case
+// of AssistantMainView, an overlay is used to parent in-Assistant notification
+// views that need to be drawn over top of Assistant cards.
+class COMPONENT_EXPORT(ASSISTANT_UI) AssistantOverlay : public views::View {
+ public:
+  // Defines parameters for how an overlay should be laid out.
+  struct LayoutParams {
+    enum Gravity {
+      kUnspecified = 0,
+      kBottom = 1 << 0,
+      kCenterHorizontal = 1 << 1,
+    };
+    int gravity = Gravity::kUnspecified;
+    gfx::Insets margins;
+  };
+
+  AssistantOverlay() = default;
+  ~AssistantOverlay() override = default;
+
+  // Returns parameters for how an overlay should be laid out.
+  virtual LayoutParams GetLayoutParams() const = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AssistantOverlay);
+};
+
+}  // namespace ash
+
+#endif  // ASH_ASSISTANT_UI_ASSISTANT_OVERLAY_H_

chromeos/services/assistant/public/features.cc

@@ -19,6 +19,9 @@ const base::Feature kAssistantWarmerWelcomeFeature{
 const base::Feature kAssistantAppSupport{"AssistantAppSupport",
                                          base::FEATURE_DISABLED_BY_DEFAULT};
 
+const base::Feature kInAssistantNotifications{
+    "InAssistantNotifications", base::FEATURE_DISABLED_BY_DEFAULT};
+
 const base::Feature kEnableDspHotword{"EnableDspHotword",
                                       base::FEATURE_DISABLED_BY_DEFAULT};
 
@@ -27,6 +30,7 @@ const base::Feature kEnableStereoAudioInput{"AssistantEnableStereoAudioInput",
 
 const base::Feature kTimerNotification{"ChromeOSAssistantTimerNotification",
                                        base::FEATURE_ENABLED_BY_DEFAULT};
+
 const base::Feature kEnableTextQueriesWithClientDiscourseContext{
     "AssistantEnableTextQueriesWithClientDiscourseContext",
     base::FEATURE_DISABLED_BY_DEFAULT};
@@ -34,6 +38,10 @@ const base::Feature kEnableTextQueriesWithClientDiscourseContext{
 const base::Feature kTimerTicks{"ChromeOSAssistantTimerTicks",
                                 base::FEATURE_DISABLED_BY_DEFAULT};
 
+bool IsInAssistantNotificationsEnabled() {
+  return base::FeatureList::IsEnabled(kInAssistantNotifications);
+}
+
 bool IsDspHotwordEnabled() {
   return base::FeatureList::IsEnabled(kEnableDspHotword);
 }

chromeos/services/assistant/public/features.h

@@ -24,6 +24,10 @@ extern const base::Feature kAssistantWarmerWelcomeFeature;
 COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC)
 extern const base::Feature kAssistantAppSupport;
 
+// Enables in-Assistant notifications.
+COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC)
+extern const base::Feature kInAssistantNotifications;
+
 // Enables DSP for hotword detection.
 COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC)
 extern const base::Feature kEnableDspHotword;
@@ -44,6 +48,9 @@ extern const base::Feature kTimerNotification;
 COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC)
 extern const base::Feature kTimerTicks;
 
+COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC)
+bool IsInAssistantNotificationsEnabled();
+
 COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC) bool IsDspHotwordEnabled();
 
 COMPONENT_EXPORT(ASSISTANT_SERVICE_PUBLIC) bool IsStereoAudioInputEnabled();