Revert of Refactor backdrop

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/frame/custom_frame_view_ash.h"
 #include "ash/public/cpp/shell_window_ids.h"
@@ skipping 26 matching lines @@
 #include "ui/display/screen.h"
 #include "ui/gfx/path.h"
 #include "ui/views/widget/widget.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_animations.h"
 #include "ui/wm/core/window_util.h"
 
+#if defined(OS_CHROMEOS)
+#include "chromeos/audio/chromeos_sounds.h"
+#endif
+
 namespace exo {
 namespace {
 
 // This is a struct for accelerator keys used to close ShellSurfaces.
 const struct Accelerator {
   ui::KeyboardCode keycode;
   int modifiers;
 } kCloseWindowAccelerators[] = {
     {ui::VKEY_W, ui::EF_CONTROL_DOWN},
     {ui::VKEY_W, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN},
@@ skipping 122 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)
+        WMHelper::GetInstance()->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 128 matching lines @@
   WMHelper::GetInstance()->RemoveActivationObserver(this);
   WMHelper::GetInstance()->RemoveDisplayConfigurationObserver(this);
   if (parent_)
     parent_->RemoveObserver(this);
   if (surface_) {
     if (scale_ != 1.0)
       surface_->window()->SetTransform(gfx::Transform());
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
   }
+  WMHelper::GetInstance()->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 645 matching lines @@
 
   if (gained_active == widget_->GetNativeWindow() ||
       lost_active == widget_->GetNativeWindow()) {
     DCHECK(activatable_);
     Configure();
     UpdateShadow();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WMHelper::AccessibilityObserver overrides:
+
+void ShellSurface::OnAccessibilityModeChanged() {
+  UpdateShadow();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // WMHelper::DisplayConfigurationObserver overrides:
 
 void ShellSurface::OnDisplayConfigurationChanged() {
   if (bounds_mode_ != BoundsMode::CLIENT)
     return;
 
   const display::Screen* screen = display::Screen::GetScreen();
   int64_t primary_display_id = screen->GetPrimaryDisplay().id();
   if (primary_display_id == primary_display_id_)
     return;
@@ skipping 174 matching lines @@
   }
 
   // Register close window accelerators.
   views::FocusManager* focus_manager = widget_->GetFocusManager();
   for (const auto& entry : kCloseWindowAccelerators) {
     focus_manager->RegisterAccelerator(
         ui::Accelerator(entry.keycode, entry.modifiers),
         ui::AcceleratorManager::kNormalPriority, this);
   }
 
+  // Receive accessibility changes to update shadow underlay.
+  WMHelper::GetInstance()->AddAccessibilityObserver(this);
+
   // Show widget next time Commit() is called.
   pending_show_widget_ = true;
 }
 
 void ShellSurface::Configure() {
   // Delay configure callback if |scoped_configure_| is set.
   if (scoped_configure_) {
     scoped_configure_->set_needs_configure();
     return;
   }
@@ skipping 318 matching lines @@
   if (!widget_ || !surface_)
     return;
   if (shadow_underlay_in_surface_ != pending_shadow_underlay_in_surface_) {
     shadow_underlay_in_surface_ = pending_shadow_underlay_in_surface_;
     shadow_overlay_.reset();
     shadow_underlay_.reset();
   }
 
   aura::Window* window = widget_->GetNativeWindow();
 
-  // Enable the black backdrop layer behind the window if the window
-  // is in immersive fullscreen, maximized, yet the window can control
-  // the bounds of the window in fullscreen/maximize mode (thus the
-  // background can be visible).
-  bool enable_backdrop =
-      (widget_->IsFullscreen() || widget_->IsMaximized()) &&
-      ash::wm::GetWindowState(window)->allow_set_bounds_direct();
-  if (window->GetProperty(aura::client::kHasBackdrop) != enable_backdrop)
-    window->SetProperty(aura::client::kHasBackdrop, enable_backdrop);
+  bool underlay_capture_events =
+      WMHelper::GetInstance()->IsSpokenFeedbackEnabled() && widget_->IsActive();
+  bool black_background_enabled =
+      ((widget_->IsFullscreen() || widget_->IsMaximized()) ||
+       underlay_capture_events) &&
+      ash::wm::GetWindowState(window)->allow_set_bounds_direct() &&
+      window->layer()->GetTargetTransform().IsIdentity();
 
-  if (!shadow_enabled_) {
+  if (!shadow_enabled_ && !black_background_enabled) {
     wm::SetShadowElevation(window, wm::ShadowElevation::NONE);
     if (shadow_underlay_)
       shadow_underlay_->Hide();
   } else {
     wm::SetShadowElevation(window, wm::ShadowElevation::DEFAULT);
     gfx::Rect shadow_content_bounds =
         gfx::ScaleToEnclosedRect(shadow_content_bounds_, 1.f / scale_);
 
     // Convert from screen to display coordinates.
     if (!shadow_content_bounds.IsEmpty()) {
@@ skipping 28 matching lines @@
     }
 
     gfx::Point shadow_origin = shadow_content_bounds.origin();
     shadow_origin -= window->bounds().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_ = base::MakeUnique<aura::Window>(nullptr);
       shadow_underlay_->set_owned_by_parent(false);
+      shadow_underlay_event_handler_ =
+          base::MakeUnique<ShadowUnderlayEventHandler>();
+      shadow_underlay_->SetTargetHandler(shadow_underlay_event_handler_.get());
       DCHECK(!shadow_underlay_->owned_by_parent());
       // 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());
       if (shadow_underlay_in_surface_) {
         surface_->window()->AddChild(shadow_underlay());
         surface_->window()->StackChildAtBottom(shadow_underlay());
       } else {
         window->AddChild(shadow_underlay());
         window->StackChildAtBottom(shadow_underlay());
       }
     }
 
     float shadow_underlay_opacity = shadow_background_opacity_;
 
+    // Put the black background layer behind the window if
+    // 1) the window is in immersive fullscreen, maximized 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 (black_background_enabled) {
+      if (shadow_underlay_in_surface_) {
+        shadow_underlay_bounds = gfx::Rect(surface_->window()->bounds().size());
+      } else {
+        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;
+    }
+
     if (!shadow_underlay_in_surface_)
       shadow_underlay_bounds = shadow_bounds;
 
     // Constrain the underlay bounds to the client area in case shell surface
     // frame is enabled.
     if (frame_enabled_) {
       shadow_underlay_bounds.Intersect(
           widget_->non_client_view()->frame_view()->GetBoundsForClientView());
     }
 
@@ skipping 45 matching lines @@
 gfx::Point ShellSurface::GetMouseLocation() const {
   aura::Window* const root_window = widget_->GetNativeWindow()->GetRootWindow();
   gfx::Point location =
       root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
   aura::Window::ConvertPointToTarget(
       root_window, widget_->GetNativeWindow()->parent(), &location);
   return location;
 }
 
 }  // namespace exo