Remove TransparentActivateWindowButton from Overview Mode

ash/wm/overview/window_grid.cc

 // Copyright 2014 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/wm/overview/window_grid.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
 #include "ash/wm/overview/window_selector.h"
+#include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/window_state.h"
 #include "base/command_line.h"
 #include "base/i18n/string_search.h"
 #include "base/memory/scoped_vector.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
+#include "ui/aura/window_targeter.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/views/background.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_animations.h"
+#include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
 typedef std::vector<aura::Window*> Windows;
 
 // An observer which holds onto the passed widget until the animation is
 // complete.
 class CleanupWidgetAfterAnimationObserver
     : public ui::ImplicitAnimationObserver {
@@ skipping 84 matching lines @@
     case WindowSelector::UP:
       vector.set_y(-bounds.width());
       break;
     case WindowSelector::LEFT:
       vector.set_x(-bounds.height());
       break;
   }
   return vector;
 }
 
+// Always returns the same target.
+class StaticWindowTargeter : public aura::WindowTargeter {
+ public:
+  explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
+  ~StaticWindowTargeter() override {}
+
+ private:
+  // aura::WindowTargeter:
+  ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+                                      ui::Event* event) override {
+    return target_;
+  }
+
+  ui::EventTarget* FindTargetForLocatedEvent(ui::EventTarget* root,
+                                             ui::LocatedEvent* event) override {
+    return target_;
+  }
+
+  aura::Window* target_;
+  DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
+};
+
 }  // namespace
 
 WindowGrid::WindowGrid(aura::Window* root_window,
                        const std::vector<aura::Window*>& windows,
                        WindowSelector* window_selector)
     : root_window_(root_window),
-      window_selector_(window_selector) {
+      window_selector_(window_selector),
+      static_targeter_container_(
+          Shell::GetContainer(root_window_, kShellWindowId_PanelContainer)) {
   WindowSelectorItem* panels_item = nullptr;
 
-  std::set<aura::Window*> panels_item_windows;
-  aura::Window* panels_parent = nullptr;
+  scoped_panel_targeter_.reset(
+      new aura::ScopedWindowTargeter(
+          static_targeter_container_,
+          scoped_ptr<ui::EventTargeter>(
+              new StaticWindowTargeter(static_targeter_container_))));
+  static_targeter_container_->set_target_handler(this);

[bruthig, 2015/01/09 17:04:33]

So will all events be consumed by this then?  ie ET_DROP_TARGET_EVENT?

[Nina, 2015/01/21 16:24:16]

They'll be intercepted, and only handled if they either activate windows or
close the overview. So if they don't they'll still move through the event chain.
Do you think there could be a problem with this?

 
   for (aura::Window::Windows::const_iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
     if ((*iter)->GetRootWindow() != root_window)
       continue;
     (*iter)->AddObserver(this);
     observed_windows_.insert(*iter);
 
     if ((*iter)->type() == ui::wm::WINDOW_TYPE_PANEL &&
         wm::GetWindowState(*iter)->panel_attached()) {
       // Attached panel windows are grouped into a single overview item per
       // grid.
       if (!panels_item) {
         panels_item = new WindowSelectorItem(root_window_);
         window_list_.push_back(panels_item);
       }
-      DCHECK(panels_parent == nullptr || panels_parent == (*iter)->parent());
-      panels_parent = (*iter)->parent();
-      panels_item_windows.insert(*iter);
+      panels_item->AddWindow(*iter);
     } else {
       WindowSelectorItem* selector_item = new WindowSelectorItem(root_window_);
       window_list_.push_back(selector_item);
       selector_item->AddWindow(*iter);
     }
   }
-
-  if (panels_item) {
-    // Sort and add panel windows in reverse z order to the WindowSelectorItem
-    // so that the transparent overlays are in the proper order.
-
-    CHECK_GT(panels_item_windows.size(), 0u);
-
-    const Windows& children = panels_parent->children();
-    for (Windows::const_reverse_iterator iter = children.rbegin();
-        iter != children.rend(); ++iter) {
-      if (panels_item_windows.find(*iter) != panels_item_windows.end())
-        panels_item->AddWindow(*iter);
-    }
-  }
 }
 
 WindowGrid::~WindowGrid() {
+  static_targeter_container_->set_target_handler(
+      static_targeter_container_->delegate());
+
   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
        iter != observed_windows_.end(); iter++) {
     (*iter)->RemoveObserver(this);
   }
 }
 
 void WindowGrid::PrepareForOverview() {
   for (ScopedVector<WindowSelectorItem>::iterator iter = window_list_.begin();
        iter != window_list_.end(); ++iter) {
     (*iter)->PrepareForOverview();
@@ skipping 199 matching lines @@
   DCHECK(iter != window_list_.end());
 
   // Immediately finish any active bounds animation.
   window->layer()->GetAnimator()->StopAnimatingProperty(
       ui::LayerAnimationElement::BOUNDS);
 
   // Recompute the transform for the window.
   (*iter)->RecomputeWindowTransforms();
 }
 
+// ui::EventHandler:
+void WindowGrid::OnMouseEvent(ui::MouseEvent* mouse) {
+  if (mouse->type() != ui::ET_MOUSE_PRESSED)
+    return;
+  HandleTap(mouse);
+}
+
+void WindowGrid::OnGestureEvent(ui::GestureEvent* gesture) {
+  if (gesture->type() != ui::ET_GESTURE_TAP)
+    return;
+  HandleTap(gesture);
+}
+
+void WindowGrid::HandleTap(ui::LocatedEvent* event) const {
+  aura::Window* selected_window = GetWindowAt(event,
+      Shell::GetContainer(root_window_, kShellWindowId_PanelContainer));
+
+  if (!selected_window) {
+    selected_window = GetWindowAt(event,
+        Shell::GetContainer(root_window_, kShellWindowId_DefaultContainer));
+    if (!selected_window) {
+      ash::Shell::GetInstance()->
+          window_selector_controller()->ToggleOverview();
+      return;
+    }
+  }
+  event->SetHandled();
+  wm::GetWindowState(selected_window)->Activate();

[bruthig, 2015/01/09 17:04:33]

How difficult would it be to move the window activation code to a single
function.  ie WindowSelectorItem::Activate() and call that function here as well
as from the handler for the LabelButton clicks?
I realize that right now it is only a single line of code but if it ever changes
or becomes two lines then having it in the same spot will make it much easier
for the next dev to update/maintain the code.

[Nina, 2015/01/21 16:24:16]

We would have to search for the WindowSelectorItem that holds the targeted
aura::Window* here and call that method. We discussed it offline and haven't
arrived at a decision on this yet.

+}
+
 void WindowGrid::InitSelectionWidget(WindowSelector::Direction direction) {
   selection_widget_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.keep_on_top = false;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = Shell::GetContainer(root_window_,
                                       kShellWindowId_DefaultContainer);
   params.accept_events = false;
@@ skipping 56 matching lines @@
     old_selection->Hide();
   }
   if (out_of_bounds)
     return;
 
   if (!selection_widget_)
     InitSelectionWidget(direction);
   // Send an a11y alert so that if ChromeVox is enabled, the item label is
   // read.
   SelectedWindow()->SendFocusAlert();
+
   // The selection widget is moved to the newly selected item in the same
   // grid.
   MoveSelectionWidgetToTarget(animate);
 }
 
 void WindowGrid::MoveSelectionWidgetToTarget(bool animate) {
   if (animate) {
     ui::ScopedLayerAnimationSettings animation_settings(
         selection_widget_->GetNativeWindow()->layer()->GetAnimator());
     animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         kOverviewSelectorTransitionMilliseconds));
     animation_settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
     animation_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     selection_widget_->SetBounds(SelectedWindow()->target_bounds());
     selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
     return;
   }
   selection_widget_->SetBounds(SelectedWindow()->target_bounds());
   selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
 }
 
+aura::Window* WindowGrid::GetWindowAt(ui::LocatedEvent* event,
+                                      aura::Window* container) const {
+  // Find the old targeter to find the target of the event.
+  ui::EventTargeter* targeter;
+  if (container == static_targeter_container_)
+    targeter = scoped_panel_targeter_->old_targeter();
+  else
+    targeter = container->GetEventTargeter();
+
+  ui::EventTarget* window = container;
+  while (!targeter && window->GetParentTarget()) {
+    window = window->GetParentTarget();
+    targeter = window->GetEventTargeter();
+  }
+  if (!targeter)
+    return nullptr;
+
+  aura::Window* target = static_cast<aura::Window*>(
+      targeter->FindTargetForLocatedEvent(container, event));
+  if (target == container)
+    return nullptr;
+
+  while (target && target->parent() != container)
+    target = target->parent();
+  aura::Window* transient_parent =
+      target ? ::wm::GetTransientParent(target) : nullptr;
+
+  return transient_parent ? transient_parent : target;
+}
+
 }  // namespace ash