Draw underlay behind android apps using talkback

components/exo/shell_surface.cc

 // Copyright 2015 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 "components/exo/shell_surface.h"
 
+#include <algorithm>
+
 #include "ash/aura/wm_window_aura.h"
+#include "ash/common/accessibility_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/system/tray/system_tray_notifier.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/window_state_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 10 matching lines @@
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/path.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_observer.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/shadow.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
 
+#if defined(OS_CHROMEOS)
+#include "chromeos/audio/chromeos_sounds.h"
+#endif
+
 DECLARE_WINDOW_PROPERTY_TYPE(std::string*)
 
 namespace exo {
 namespace {
 
 // This is a struct for accelerator keys used to close ShellSurfaces.
 const struct Accelerator {
   ui::KeyboardCode keycode;
   int modifiers;
 } kCloseWindowAccelerators[] = {
@@ skipping 30 matching lines @@
   void SizeConstraintsChanged() override {}
 
  private:
   views::Widget* const widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFrameView);
 };
 
 class CustomWindowTargeter : public aura::WindowTargeter {
  public:
-  CustomWindowTargeter() {}
+  CustomWindowTargeter(views::Widget* widget) : widget_(widget) {}
   ~CustomWindowTargeter() override {}
 
   // Overridden from aura::WindowTargeter:
   bool EventLocationInsideBounds(aura::Window* window,
                                  const ui::LocatedEvent& event) const override {
     Surface* surface = ShellSurface::GetMainSurface(window);
     if (!surface)
       return false;
 
     gfx::Point local_point = event.location();
+
+    // If the underlay is accepting events, test against it's bounds instead
+    // since it will be larger than (and contain) the surface's bounds.
+    aura::Window* shadow_underlay =
+        static_cast<ShellSurface*>(
+            widget_->widget_delegate()->GetContentsView())
+            ->shadow_underlay();
+    if (shadow_underlay && !shadow_underlay->ignore_events()) {
+      aura::Window::ConvertPointToTarget(window->parent(), shadow_underlay,

[reveman, 2016/09/30 20:51:10]

It's confusing that one piece of code assumes window->parent() is non-null and
one piece (below) does not. Please make it consistent. If you change the code
below then please reduce it to one ConvertPointToTarget call.

[erosky, 2016/09/30 21:24:16]

Done.

+                                         &local_point);
+      return gfx::Rect(shadow_underlay->layer()->size()).Contains(local_point);
+    }
+
     if (window->parent())
       aura::Window::ConvertPointToTarget(window->parent(), window,
                                          &local_point);
 
     aura::Window::ConvertPointToTarget(window, surface->window(), &local_point);
     return surface->HitTestRect(gfx::Rect(local_point, gfx::Size(1, 1)));
   }
 
+  ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,

[reveman, 2016/09/30 20:51:10]

FYI, sub-surface can have bounds outside the surface so this is broken for that
case but it was broken before too so no need to fix as part of this patch.

[erosky, 2016/09/30 21:24:16]

Acknowledged.

+                                      ui::Event* event) override {
+    aura::Window* window = static_cast<aura::Window*>(root);
+    Surface* surface = ShellSurface::GetMainSurface(window);
+
+    // Send events which are outside of the surface's bounds to the underlay.
+    aura::Window* shadow_underlay =
+        static_cast<ShellSurface*>(
+            widget_->widget_delegate()->GetContentsView())
+            ->shadow_underlay();
+    if (surface && event->IsLocatedEvent() && shadow_underlay &&
+        !shadow_underlay->ignore_events()) {
+      gfx::Point local_point = event->AsLocatedEvent()->location();
+      aura::Window::ConvertPointToTarget(window, surface->window(),
+                                         &local_point);
+      if (!surface->HitTestRect(gfx::Rect(local_point, gfx::Size(1, 1))))
+        return shadow_underlay;
+    }
+    return aura::WindowTargeter::FindTargetForEvent(root, event);
+  }
+
  private:
+  views::Widget* widget_;

[reveman, 2016/09/30 20:51:10]

nit: views::Widget* const widget_;

[erosky, 2016/09/30 21:24:16]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(CustomWindowTargeter);
 };
 
 // Handles a user's fullscreen request (Shift+F4/F4).
 class CustomWindowStateDelegate : public ash::wm::WindowStateDelegate,
                                   public views::WidgetObserver {
  public:
   explicit CustomWindowStateDelegate(views::Widget* widget) : widget_(widget) {
     widget_->AddObserver(this);
   }
@@ skipping 39 matching lines @@
     if (GetFocusManager()->ProcessAccelerator(ui::Accelerator(*event)))
       event->StopPropagation();
   }
 
  private:
   ShellSurface* const shell_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellSurfaceWidget);
 };
 
+class ShadowUnderlayEventHandler : public ui::EventHandler {
+ public:
+  ShadowUnderlayEventHandler() {}
+  ~ShadowUnderlayEventHandler() override {}
+
+  // Overridden from ui::EventHandler:
+  void OnEvent(ui::Event* event) override {
+    // If the event is targeted at the underlay, it means the user has made an
+    // interaction that is outside the surface's bounds and we want to capture
+    // it (usually when in spoken feedback mode). Handle the event (to prevent
+    // behind-windows from receiving it) and play an earcon to notify the user.
+    if (event->IsLocatedEvent()) {
+#if defined(OS_CHROMEOS)
+      const ui::EventType kEarconEventTypes[] = {ui::ET_MOUSE_PRESSED,
+                                                 ui::ET_MOUSEWHEEL,
+                                                 ui::ET_TOUCH_PRESSED,
+                                                 ui::ET_POINTER_DOWN,
+                                                 ui::ET_POINTER_WHEEL_CHANGED,
+                                                 ui::ET_GESTURE_BEGIN,
+                                                 ui::ET_SCROLL,
+                                                 ui::ET_SCROLL_FLING_START};
+      bool is_earcon_event_type =
+          std::find(std::begin(kEarconEventTypes), std::end(kEarconEventTypes),
+                    event->type()) != std::end(kEarconEventTypes);
+      if (is_earcon_event_type)
+        ash::WmShell::Get()->accessibility_delegate()->PlayEarcon(
+            chromeos::SOUND_VOLUME_ADJUST);
+#endif
+      event->SetHandled();
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ShadowUnderlayEventHandler);
+};
+
 }  // namespace
 
 // Helper class used to coalesce a number of changes into one "configure"
 // callback. Callbacks are suppressed while an instance of this class is
 // instantiated and instead called when the instance is destroyed.
 // If |force_configure_| is true ShellSurface::Configure() will be called
 // even if no changes to shell surface took place during the lifetime of the
 // ScopedConfigure instance.
 class ShellSurface::ScopedConfigure {
  public:
@@ skipping 116 matching lines @@
   }
   WMHelper::GetInstance()->RemoveActivationObserver(this);
   if (parent_)
     parent_->RemoveObserver(this);
   if (surface_) {
     if (scale_ != 1.0)
       surface_->window()->SetTransform(gfx::Transform());
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
   }
+  ash::WmShell::Get()->system_tray_notifier()->RemoveAccessibilityObserver(
+      this);
 }
 
 void ShellSurface::AcknowledgeConfigure(uint32_t serial) {
   TRACE_EVENT1("exo", "ShellSurface::AcknowledgeConfigure", "serial", serial);
 
   // Apply all configs that are older or equal to |serial|. The result is that
   // the origin of the main surface will move and the resize direction will
   // change to reflect the acknowledgement of configure request with |serial|
   // at the next call to Commit().
   while (!pending_configs_.empty()) {
@@ skipping 404 matching lines @@
 // views::Views overrides:
 
 gfx::Size ShellSurface::GetPreferredSize() const {
   if (!geometry_.IsEmpty())
     return geometry_.size();
 
   return surface_ ? surface_->window()->layer()->size() : gfx::Size();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// ash::AccessibilityObserver overrides:
+
+void ShellSurface::OnAccessibilityModeChanged(
+    ash::AccessibilityNotificationVisibility) {
+  UpdateShadow();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // ash::wm::WindowStateObserver overrides:
 
 void ShellSurface::OnPreWindowStateTypeChange(
     ash::wm::WindowState* window_state,
     ash::wm::WindowStateType old_type) {
   ash::wm::WindowStateType new_type = window_state->GetStateType();
   if (ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(old_type) ||
       ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(new_type)) {
     // When transitioning in/out of maximized or fullscreen mode we need to
     // make sure we have a configure callback before we allow the default
@@ skipping 75 matching lines @@
 void ShellSurface::OnWindowActivated(
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (!widget_)
     return;
 
   if (gained_active == widget_->GetNativeWindow() ||
       lost_active == widget_->GetNativeWindow()) {
     DCHECK(activatable_);
     Configure();
+    UpdateShadow();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void ShellSurface::OnKeyEvent(ui::KeyEvent* event) {
   if (!resizer_) {
     views::View::OnKeyEvent(event);
     return;
@@ skipping 95 matching lines @@
   params.activatable = activatable ? views::Widget::InitParams::ACTIVATABLE_YES
                                    : views::Widget::InitParams::ACTIVATABLE_NO;
 
   // Note: NativeWidget owns this widget.
   widget_ = new ShellSurfaceWidget(this);
   widget_->Init(params);
 
   aura::Window* window = widget_->GetNativeWindow();
   window->SetName("ExoShellSurface");
   window->AddChild(surface_->window());
-  window->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
+  window->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter(widget_)));
   SetApplicationId(window, &application_id_);
   SetMainSurface(window, surface_);
 
   // Start tracking changes to window bounds and window state.
   window->AddObserver(this);
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
   window_state->AddObserver(this);
 
   // Absolete positioned shell surfaces may request the bounds that does not
   // fill the entire work area / display in maximized / fullscreen state.
@@ skipping 25 matching lines @@
   for (const auto& entry : kCloseWindowAccelerators) {
     focus_manager->RegisterAccelerator(
         ui::Accelerator(entry.keycode, entry.modifiers),
         ui::AcceleratorManager::kNormalPriority, this);
   }
 
   // Set delegate for handling of fullscreening.
   window_state->SetDelegate(std::unique_ptr<ash::wm::WindowStateDelegate>(
       new CustomWindowStateDelegate(widget_)));
 
+  // Receive accessibility changes to update shadow underlay.
+  ash::WmShell::Get()->system_tray_notifier()->AddAccessibilityObserver(this);
+
   // Show widget next time Commit() is called.
   pending_show_widget_ = true;
 }
 
 void ShellSurface::Configure() {
   DCHECK(widget_);
 
   // Delay configure callback if |scoped_configure_| is set.
   if (scoped_configure_) {
     scoped_configure_->set_needs_configure();
@@ skipping 239 matching lines @@
     // TODO(oshima): Adjust the coordinates from client screen to
     // chromeos screen when multi displays are supported.
     gfx::Point origin = window->bounds().origin();
     gfx::Point shadow_origin = shadow_content_bounds_.origin();
     shadow_origin -= origin.OffsetFromOrigin();
     gfx::Rect shadow_bounds(shadow_origin, shadow_content_bounds_.size());
 
     // Always create and show the underlay, even in maximized/fullscreen.
     if (!shadow_underlay_) {
       shadow_underlay_ = new aura::Window(nullptr);
+      shadow_underlay_handler_ = base::MakeUnique<ShadowUnderlayEventHandler>();
+      shadow_underlay_->SetTargetHandler(shadow_underlay_handler_.get());
       DCHECK(shadow_underlay_->owned_by_parent());
-      shadow_underlay_->set_ignore_events(true);
       // Ensure the background area inside the shadow is solid black.
       // Clients that provide translucent contents should not be using
       // rectangular shadows as this method requires opaque contents to
       // cast a shadow that represent it correctly.
       shadow_underlay_->Init(ui::LAYER_SOLID_COLOR);
       shadow_underlay_->layer()->SetColor(SK_ColorBLACK);
       DCHECK(shadow_underlay_->layer()->fills_bounds_opaquely());
       window->AddChild(shadow_underlay_);
       window->StackChildAtBottom(shadow_underlay_);
     }
 
+    bool underlay_capture_events = ash::WmShell::Get()
+                                       ->accessibility_delegate()
+                                       ->IsSpokenFeedbackEnabled() &&
+                                   widget_->IsActive();
+    shadow_underlay_->set_ignore_events(!underlay_capture_events);
+
     float shadow_underlay_opacity = rectangular_shadow_background_opacity_;
     // Put the black background layer behind the window if
-    // 1) the window is in immersive fullscreen.
+    // 1) the window is in immersive fullscreen or is active with
+    //    spoken feedback enabled.
     // 2) the window can control the bounds of the window in fullscreen (
     //    thus the background can be visible).
     // 3) the window has no transform (the transformed background may
     //    not cover the entire background, e.g. overview mode).
-    if (widget_->IsFullscreen() &&
+    if ((widget_->IsFullscreen() || underlay_capture_events) &&
         ash::wm::GetWindowState(window)->allow_set_bounds_in_maximized() &&
-        window->layer()->transform().IsIdentity()) {
+        window->layer()->GetTargetTransform().IsIdentity()) {
       gfx::Point origin;
       origin -= window->bounds().origin().OffsetFromOrigin();
       shadow_bounds.set_origin(origin);
       shadow_bounds.set_size(window->parent()->bounds().size());
       shadow_underlay_opacity = 1.0f;
     }
 
     shadow_underlay_->SetBounds(shadow_bounds);
 
     // TODO(oshima): Setting to the same value should be no-op.
@@ skipping 18 matching lines @@
       shadow_overlay_->layer()->Add(shadow->layer());
       window->AddChild(shadow_overlay_);
       shadow_overlay_->Show();
     }
     shadow_overlay_->SetBounds(shadow_bounds);
     shadow->SetContentBounds(gfx::Rect(shadow_bounds.size()));
   }
 }
 
 }  // namespace exo