Hide Assistant when interacting outside bounds.

Previously we relied on deactivation of the Assistant widget to tell us
when we should hide Assistant UI. This did not work in all cases because
the user can interact with the Desktop our Settings tray without causing
inactivation of the widget.

Now, we register an EventMonitor to watch for events on our root window
while Assistant UI is visible. If a press event happens outside our
bounds, we hide Assistant UI.

Note that in testing this did not cause any unexpected behavior with
regards to metalayer.

This CL was adapted from logic implemented here:
https://cs.chromium.org/chromium/src/ash/system/tray/tray_event_filter.cc?type=cs&g=0&l=38-115

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

ash/assistant/assistant_ui_controller.cc

@@ -73,13 +73,8 @@ void AssistantUiController::RemoveModelObserver(
 
 void AssistantUiController::OnWidgetActivationChanged(views::Widget* widget,
                                                       bool active) {
-  if (active) {
+  if (active)
     container_view_->RequestFocus();
-  } else {
-    // When the widget is deactivated the UI should hide. Interacting with
-    // the metalayer does not cause widget deactivation.
-    HideUi(AssistantSource::kUnspecified);
-  }
 }
 
 void AssistantUiController::OnWidgetVisibilityChanged(views::Widget* widget,
@@ -227,16 +222,39 @@ void AssistantUiController::OnUiVisibilityChanged(
           ? mojom::VoiceInteractionState::RUNNING
           : mojom::VoiceInteractionState::STOPPED);
 
-  if (new_visibility == AssistantVisibility::kHidden) {
-    // When hiding the UI, start a timer to automatically close ourselves after
-    // |kAutoCloseThreshold|. This is to give the user an opportunity to resume
-    // their previous session before it is automatically finished.
-    auto_close_timer_.Start(FROM_HERE, kAutoCloseThreshold,
+  switch (new_visibility) {
+    case AssistantVisibility::kClosed:
+      // When the UI is closed, we stop the auto close timer as it may be
+      // running and also stop monitoring events.
+      auto_close_timer_.Stop();
+      event_monitor_.reset();
+      break;
+    case AssistantVisibility::kHidden:
+      // When hiding the UI, we start a timer to automatically close ourselves
+      // after |kAutoCloseThreshold|. This is to give the user an opportunity to
+      // resume their previous session before it is automatically finished.
+      auto_close_timer_.Start(
+          FROM_HERE, kAutoCloseThreshold,
           base::BindRepeating(&AssistantUiController::CloseUi,
                               weak_factory_.GetWeakPtr(),
                               AssistantSource::kUnspecified));
-  } else {
+
+      // Because the UI is not visible we needn't monitor events.
+      event_monitor_.reset();
+      break;
+    case AssistantVisibility::kVisible:
+      // Upon becoming visible, we stop the auto close timer.
       auto_close_timer_.Stop();
+
+      // We need to monitor events for the root window while we're visible to
+      // give us an opportunity to dismiss Assistant UI when the user starts an
+      // interaction outside of our bounds. TODO(dmblack): Investigate how this
+      // behaves in a multi-display environment.
+      gfx::NativeWindow root_window =
+          container_view_->GetWidget()->GetNativeWindow()->GetRootWindow();
+      event_monitor_ =
+          views::EventMonitor::CreateWindowMonitor(this, root_window);
+      break;
   }
 
   // Metalayer should not be sticky. Disable when the UI is no longer visible.
@@ -381,6 +399,34 @@ void AssistantUiController::OnDisplayMetricsChanged(
   }
 }
 
+void AssistantUiController::OnMouseEvent(ui::MouseEvent* event) {
+  if (event->type() == ui::ET_MOUSE_PRESSED)
+    OnPressedEvent(*event);
+}
+
+void AssistantUiController::OnTouchEvent(ui::TouchEvent* event) {
+  if (event->type() == ui::ET_TOUCH_PRESSED)
+    OnPressedEvent(*event);
+}
+
+void AssistantUiController::OnPressedEvent(const ui::LocatedEvent& event) {
+  DCHECK(event.type() == ui::ET_MOUSE_PRESSED ||
+         event.type() == ui::ET_TOUCH_PRESSED);
+
+  const gfx::Point screen_location =
+      event.target() ? event.target()->GetScreenLocation(event)
+                     : event.root_location();
+
+  const gfx::Rect screen_bounds =
+      container_view_->GetWidget()->GetWindowBoundsInScreen();
+
+  // Pressed events outside our widget bounds should result in hiding of
+  // Assistant UI. This event does not fire during a Metalayer session so we
+  // needn't enforce logic to prevent hiding when using the stylus.
+  if (!screen_bounds.Contains(screen_location))
+    HideUi(AssistantSource::kUnspecified);
+}
+
 void AssistantUiController::UpdateUsableWorkArea(aura::Window* root_window) {
   gfx::Rect usable_work_area;
   gfx::Rect screen_bounds = root_window->GetBoundsInScreen();

ash/assistant/assistant_ui_controller.h

@@ -21,8 +21,10 @@
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "ui/display/display_observer.h"
+#include "ui/events/event_handler.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
+#include "ui/views/event_monitor.h"
 #include "ui/views/widget/widget_observer.h"
 
 namespace chromeos {
@@ -53,7 +55,8 @@ class ASH_EXPORT AssistantUiController
       public DialogPlateObserver,
       public HighlighterController::Observer,
       public keyboard::KeyboardControllerObserver,
-      public display::DisplayObserver {
+      public display::DisplayObserver,
+      public ui::EventHandler {
  public:
   explicit AssistantUiController(AssistantController* assistant_controller);
   ~AssistantUiController() override;
@@ -115,6 +118,10 @@ class ASH_EXPORT AssistantUiController
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t changed_metrics) override;
 
+  // ui::EventHandler:
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+
   void ShowUi(AssistantSource source);
   void HideUi(AssistantSource source);
   void CloseUi(AssistantSource source);
@@ -123,6 +130,9 @@ class ASH_EXPORT AssistantUiController
   AssistantContainerView* GetViewForTest();
 
  private:
+  // Invoked on either a mouse or touch pressed event.
+  void OnPressedEvent(const ui::LocatedEvent& event);
+
   // Updates UI mode to |ui_mode| if specified. Otherwise UI mode is updated on
   // the basis of interaction/widget visibility state.
   void UpdateUiMode(base::Optional<AssistantUiMode> ui_mode = base::nullopt);
@@ -146,6 +156,8 @@ class ASH_EXPORT AssistantUiController
   AssistantContainerView* container_view_ =
       nullptr;  // Owned by view hierarchy.
 
+  std::unique_ptr<views::EventMonitor> event_monitor_;
+
   gfx::Rect keyboard_workspace_occluded_bounds_;
 
   // When hidden, Assistant automatically closes itself to finish the previous