Remove TransparentActivateWindowButton from Overview Mode

ash/wm/overview/window_grid.cc

Index: ash/wm/overview/window_grid.cc
diff --git a/ash/wm/overview/window_grid.cc b/ash/wm/overview/window_grid.cc
index defc09bea24ec489ecefdae1003f5f2156406760..97d3923a3136b60d69188693cba2843902d053f9 100644
--- a/ash/wm/overview/window_grid.cc
+++ b/ash/wm/overview/window_grid.cc
@@ -15,13 +15,17 @@
 #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"
@@ -30,6 +34,7 @@
 #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 {
@@ -134,17 +139,45 @@ gfx::Vector2d GetSlideVectorForFadeIn(WindowSelector::Direction direction,
   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) {
@@ -161,32 +194,19 @@ WindowGrid::WindowGrid(aura::Window* root_window,
         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);
@@ -406,6 +426,36 @@ void WindowGrid::OnWindowBoundsChanged(aura::Window* 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;
@@ -482,6 +532,7 @@ void WindowGrid::MoveSelectionWidget(WindowSelector::Direction 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);
@@ -504,4 +555,34 @@ void WindowGrid::MoveSelectionWidgetToTarget(bool animate) {
   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