cros: allow aura window not considered activatable for pointer event

ui/wm/core/focus_controller.cc

 // Copyright (c) 2012 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 "ui/wm/core/focus_controller.h"
 
 #include "base/auto_reset.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
@@ skipping 20 matching lines @@
     transient_parent = wm::GetTransientParent(transient_parent);
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, public:
 
 FocusController::FocusController(FocusRules* rules)
-    : active_window_(NULL),
-      focused_window_(NULL),
+    : active_window_(nullptr),
+      focused_window_(nullptr),
       updating_focus_(false),
       updating_activation_(false),
       rules_(rules),
       observer_manager_(this) {
   DCHECK(rules);
 }
 
-FocusController::~FocusController() {
-}
+FocusController::~FocusController() = default;
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, aura::client::ActivationClient implementation:
 
 void FocusController::AddObserver(
     aura::client::ActivationChangeObserver* observer) {
   activation_observers_.AddObserver(observer);
 }
 
 void FocusController::RemoveObserver(
@@ skipping 58 matching lines @@
   return focused_window_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, ui::EventHandler implementation:
 void FocusController::OnKeyEvent(ui::KeyEvent* event) {
 }
 
 void FocusController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED && !event->handled())
-    WindowFocusedFromInputEvent(static_cast<aura::Window*>(event->target()));
+    WindowFocusedFromInputEvent(static_cast<aura::Window*>(event->target()),
+                                event);
 }
 
 void FocusController::OnScrollEvent(ui::ScrollEvent* event) {
 }
 
 void FocusController::OnTouchEvent(ui::TouchEvent* event) {
 }
 
 void FocusController::OnGestureEvent(ui::GestureEvent* event) {
   if (event->type() == ui::ET_GESTURE_BEGIN &&
       event->details().touch_points() == 1 &&
       !event->handled()) {
-    WindowFocusedFromInputEvent(static_cast<aura::Window*>(event->target()));
+    WindowFocusedFromInputEvent(static_cast<aura::Window*>(event->target()),
+                                event);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, aura::WindowObserver implementation:
 
 void FocusController::OnWindowVisibilityChanged(aura::Window* window,
                                                 bool visible) {
   if (!visible)
     WindowLostFocusFromDispositionChange(window, window->parent());
@@ skipping 35 matching lines @@
   if (window &&
       (window->Contains(focused_window_) || window->Contains(active_window_))) {
     StackActiveWindow();
     return;
   }
 
   // Focusing a window also activates its containing activatable window. Note
   // that the rules could redirect activation activation and/or focus.
   aura::Window* focusable = rules_->GetFocusableWindow(window);
   aura::Window* activatable =
-      focusable ? rules_->GetActivatableWindow(focusable) : NULL;
+      focusable ? rules_->GetActivatableWindow(focusable) : nullptr;
 
   // We need valid focusable/activatable windows in the event we're not clearing
   // focus. "Clearing focus" is inferred by whether or not |window| passed to
   // this function is non-NULL.
   if (window && (!focusable || !activatable))
     return;
   DCHECK((focusable && activatable) || !window);
 
   // Activation change observers may change the focused window. If this happens
   // we must not adjust the focus below since this will clobber that change.
   aura::Window* last_focused_window = focused_window_;
   if (!updating_activation_)
     SetActiveWindow(reason, window, activatable);
 
   // If the window's ActivationChangeObserver shifted focus to a valid window,
   // we don't want to focus the window we thought would be focused by default.
   bool activation_changed_focus = last_focused_window != focused_window_;
   if (!updating_focus_ && (!activation_changed_focus || !focused_window_)) {
     if (active_window_ && focusable)
       DCHECK(active_window_->Contains(focusable));
     SetFocusedWindow(focusable);
   }
 }
 
 void FocusController::SetFocusedWindow(aura::Window* window) {
   if (updating_focus_ || window == focused_window_)
     return;
-  DCHECK(rules_->CanFocusWindow(window));
+  DCHECK(rules_->CanFocusWindow(window, nullptr));
   if (window)
     DCHECK_EQ(window, rules_->GetFocusableWindow(window));
 
   base::AutoReset<bool> updating_focus(&updating_focus_, true);
   aura::Window* lost_focus = focused_window_;
 
   // Allow for the window losing focus to be deleted during dispatch. If it is
   // deleted pass NULL to observers instead of a deleted window.
   aura::WindowTracker window_tracker;
   if (lost_focus)
     window_tracker.Add(lost_focus);
   if (focused_window_ && observer_manager_.IsObserving(focused_window_) &&
       focused_window_ != active_window_) {
     observer_manager_.Remove(focused_window_);
   }
   focused_window_ = window;
   if (focused_window_ && !observer_manager_.IsObserving(focused_window_))
     observer_manager_.Add(focused_window_);
 
   for (auto& observer : focus_observers_) {
     observer.OnWindowFocused(
         focused_window_,
-        window_tracker.Contains(lost_focus) ? lost_focus : NULL);
+        window_tracker.Contains(lost_focus) ? lost_focus : nullptr);
   }
   if (window_tracker.Contains(lost_focus)) {
     aura::client::FocusChangeObserver* observer =
         aura::client::GetFocusChangeObserver(lost_focus);
     if (observer)
       observer->OnWindowFocused(focused_window_, lost_focus);
   }
   aura::client::FocusChangeObserver* observer =
       aura::client::GetFocusChangeObserver(focused_window_);
   if (observer) {
     observer->OnWindowFocused(
         focused_window_,
-        window_tracker.Contains(lost_focus) ? lost_focus : NULL);
+        window_tracker.Contains(lost_focus) ? lost_focus : nullptr);
   }
 }
 
 void FocusController::SetActiveWindow(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* requested_window,
     aura::Window* window) {
   if (updating_activation_)
     return;
 
@@ skipping 19 matching lines @@
   if (active_window_ && observer_manager_.IsObserving(active_window_) &&
       focused_window_ != active_window_) {
     observer_manager_.Remove(active_window_);
   }
   active_window_ = window;
   if (active_window_ && !observer_manager_.IsObserving(active_window_))
     observer_manager_.Add(active_window_);
   if (active_window_)
     StackActiveWindow();
 
-  aura::client::ActivationChangeObserver* observer = NULL;
+  aura::client::ActivationChangeObserver* observer = nullptr;
   if (window_tracker.Contains(lost_activation)) {
     observer = aura::client::GetActivationChangeObserver(lost_activation);
     if (observer)
       observer->OnWindowActivated(reason, active_window_, lost_activation);
   }
   observer = aura::client::GetActivationChangeObserver(active_window_);
   if (observer) {
     observer->OnWindowActivated(
         reason, active_window_,
-        window_tracker.Contains(lost_activation) ? lost_activation : NULL);
+        window_tracker.Contains(lost_activation) ? lost_activation : nullptr);
   }
   for (auto& observer : activation_observers_) {
     observer.OnWindowActivated(
         reason, active_window_,
-        window_tracker.Contains(lost_activation) ? lost_activation : NULL);
+        window_tracker.Contains(lost_activation) ? lost_activation : nullptr);
   }
 }
 
 void FocusController::StackActiveWindow() {
   if (active_window_) {
     StackTransientParentsBelowModalWindow(active_window_);
     active_window_->parent()->StackChildAtTop(active_window_);
   }
 }
 
 void FocusController::WindowLostFocusFromDispositionChange(
     aura::Window* window,
     aura::Window* next) {
   // TODO(beng): See if this function can be replaced by a call to
   //             FocusWindow().
   // Activation adjustments are handled first in the event of a disposition
   // changed. If an activation change is necessary, focus is reset as part of
   // that process so there's no point in updating focus independently.
   if (window == active_window_) {
     aura::Window* next_activatable = rules_->GetNextActivatableWindow(window);
     SetActiveWindow(aura::client::ActivationChangeObserver::ActivationReason::
                         WINDOW_DISPOSITION_CHANGED,
-                    NULL, next_activatable);
+                    nullptr, next_activatable);
     if (!(active_window_ && active_window_->Contains(focused_window_)))
       SetFocusedWindow(next_activatable);
   } else if (window->Contains(focused_window_)) {
     // Active window isn't changing, but focused window might be.
     SetFocusedWindow(rules_->GetFocusableWindow(next));
   }
 }
 
-void FocusController::WindowFocusedFromInputEvent(aura::Window* window) {
+void FocusController::WindowFocusedFromInputEvent(aura::Window* window,
+                                                  ui::Event* event) {
   // Only focus |window| if it or any of its parents can be focused. Otherwise
   // FocusWindow() will focus the topmost window, which may not be the
   // currently focused one.
-  if (rules_->CanFocusWindow(GetToplevelWindow(window))) {
+  if (rules_->CanFocusWindow(GetToplevelWindow(window), event)) {
     FocusAndActivateWindow(
         aura::client::ActivationChangeObserver::ActivationReason::INPUT_EVENT,
         window);
   }
 }
 
 }  // namespace wm