Make a pure mojo::View version of the aura::Window FocusController.

mojo/services/window_manager/focus_controller.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 "mojo/services/window_manager/focus_controller.h"
+
+#include "base/auto_reset.h"
+#include "mojo/services/public/cpp/view_manager/view_tracker.h"
+#include "mojo/services/window_manager/focus_controller_observer.h"
+#include "mojo/services/window_manager/focus_rules.h"
+#include "mojo/services/window_manager/view_target.h"
+#include "mojo/services/window_manager/window_manager_app.h"
+#include "ui/events/event.h"
+
+namespace mojo {
+
+FocusController::FocusController(scoped_ptr<FocusRules> rules)
+    : active_view_(nullptr),
+      focused_view_(nullptr),
+      updating_focus_(false),
+      updating_activation_(false),
+      rules_(rules.Pass()),
+      observer_manager_(this) {
+  DCHECK(rules_);
+}
+
+FocusController::~FocusController() {}
+
+void FocusController::AddObserver(FocusControllerObserver* observer) {
+  focus_controller_observers_.AddObserver(observer);
+}
+
+void FocusController::RemoveObserver(FocusControllerObserver* observer) {
+  focus_controller_observers_.RemoveObserver(observer);
+}
+
+void FocusController::ActivateView(View* view) {
+  FocusView(view);
+}
+
+void FocusController::DeactivateView(View* view) {
+  if (view)
+    FocusView(rules_->GetNextActivatableView(view));
+}
+
+View* FocusController::GetActiveView() {
+  return active_view_;
+}
+
+View* FocusController::GetActivatableView(View* view) {
+  return rules_->GetActivatableView(view);
+}
+
+View* FocusController::GetToplevelView(View* view) {
+  return rules_->GetToplevelView(view);
+}
+
+bool FocusController::CanActivateView(View* view) const {
+  return rules_->CanActivateView(view);
+}
+
+void FocusController::FocusView(View* view) {
+  if (view &&
+      (view->Contains(focused_view_) || view->Contains(active_view_))) {
+    return;
+  }
+
+  // TODO(erg): We need to early abort in the of a view having
+  // capture. However, we currently don't have a capture client here.
+
+  // Focusing a window also activates its containing activatable window. Note
+  // that the rules could redirect activation activation and/or focus.
+  View* focusable = rules_->GetFocusableView(view);
+  View* activatable =
+      focusable ? rules_->GetActivatableView(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 (view && (!focusable || !activatable))
+    return;
+  DCHECK((focusable && activatable) || !view);
+
+  // Activation change observers may change the focused window. If this happens
+  // we must not adjust the focus below since this will clobber that change.
+  View* last_focused_view = focused_view_;
+  if (!updating_activation_)
+    SetActiveView(view, 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_view != focused_view_;
+  if (!updating_focus_ && (!activation_changed_focus || !focused_view_)) {
+    if (active_view_ && focusable)
+      DCHECK(active_view_->Contains(focusable));
+    SetFocusedView(focusable);
+  }
+}
+
+void FocusController::ResetFocusWithinActiveView(View* view) {
+  DCHECK(view);
+  if (!active_view_)
+    return;
+  if (!active_view_->Contains(view))
+    return;
+  SetFocusedView(view);
+}
+
+View* FocusController::GetFocusedView() {
+  return focused_view_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 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()) {
+    View* view = mojo::WindowManagerApp::GetViewForViewTarget(
+        static_cast<ViewTarget*>(event->target()));
+    ViewFocusedFromInputEvent(view);
+  }
+}
+
+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()) {
+    View* view = mojo::WindowManagerApp::GetViewForViewTarget(
+        static_cast<ViewTarget*>(event->target()));
+    ViewFocusedFromInputEvent(view);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FocusController, aura::WindowObserver implementation:
+
+void FocusController::OnViewVisibilityChanged(View* view) {
+  bool visible = view->visible();
+  if (!visible)
+    ViewLostFocusFromDispositionChange(view, view->parent());
+}
+
+void FocusController::OnViewDestroying(View* view) {
+  ViewLostFocusFromDispositionChange(view, view->parent());
+}
+
+void FocusController::OnTreeChanging(const TreeChangeParams& params) {
+  // TODO(erg): In the aura version, you could get into a situation where you
+  // have different focus clients, so you had to check for that. Does that
+  // happen here? Could we get away with not checking if it does?
+  if (params.receiver == active_view_ &&
+      params.target->Contains(params.receiver) &&
+      (!params.new_parent ||
+       /* different_focus_clients */ false)) {
+    ViewLostFocusFromDispositionChange(params.receiver, params.old_parent);
+  }
+}
+
+void FocusController::OnTreeChanged(const TreeChangeParams& params) {
+  // TODO(erg): Same as Changing version.
+  if (params.receiver == focused_view_ &&
+      params.target->Contains(params.receiver) &&
+      (!params.new_parent ||
+       /* different_focus_clients */ false)) {
+    ViewLostFocusFromDispositionChange(params.receiver, params.old_parent);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FocusController, private:
+
+void FocusController::SetFocusedView(View* view) {
+  if (updating_focus_ || view == focused_view_)
+    return;
+  DCHECK(rules_->CanFocusView(view));
+  if (view)
+    DCHECK_EQ(view, rules_->GetFocusableView(view));
+
+  base::AutoReset<bool> updating_focus(&updating_focus_, true);
+  View* lost_focus = focused_view_;
+
+  // TODO(erg): In the aura version, we reset the text input client here. Do
+  // that if we bring in something like the TextInputClient.
+
+  // Allow for the window losing focus to be deleted during dispatch. If it is
+  // deleted pass null to observers instead of a deleted window.
+  ViewTracker view_tracker;
+  if (lost_focus)
+    view_tracker.Add(lost_focus);
+  if (focused_view_ && observer_manager_.IsObserving(focused_view_) &&
+      focused_view_ != active_view_) {
+    observer_manager_.Remove(focused_view_);
+  }
+  focused_view_ = view;
+  if (focused_view_ && !observer_manager_.IsObserving(focused_view_))
+    observer_manager_.Add(focused_view_);
+
+  FOR_EACH_OBSERVER(FocusControllerObserver,
+                    focus_controller_observers_,
+                    OnViewFocused(focused_view_,
+                                  view_tracker.Contains(lost_focus) ?
+                                  lost_focus : nullptr));
+
+  // TODO(erg): In aura, there's a concept of a single FocusChangeObserver that
+  // is attached to an aura::Window. We don't currently have this in
+  // mojo::View, but if we add it later, we should make something analogous
+  // here.
+
+  // TODO(erg): In the aura version, we reset the TextInputClient here, too.
+}
+
+void FocusController::SetActiveView(View* requested_view, View* view) {
+  if (updating_activation_)
+    return;
+
+  if (view == active_view_) {
+    if (requested_view) {
+      FOR_EACH_OBSERVER(FocusControllerObserver,
+                        focus_controller_observers_,
+                        OnAttemptToReactivateView(requested_view,
+                                                  active_view_));
+    }
+    return;
+  }
+
+  DCHECK(rules_->CanActivateView(view));
+  if (view)
+    DCHECK_EQ(view, rules_->GetActivatableView(view));
+
+  base::AutoReset<bool> updating_activation(&updating_activation_, true);
+  View* lost_activation = active_view_;
+  // Allow for the window losing activation to be deleted during dispatch. If
+  // it is deleted pass null to observers instead of a deleted window.
+  ViewTracker view_tracker;
+  if (lost_activation)
+    view_tracker.Add(lost_activation);
+  if (active_view_ && observer_manager_.IsObserving(active_view_) &&
+      focused_view_ != active_view_) {
+    observer_manager_.Remove(active_view_);
+  }
+  active_view_ = view;
+  if (active_view_ && !observer_manager_.IsObserving(active_view_))
+    observer_manager_.Add(active_view_);
+
+  if (active_view_) {
+    // TODO(erg): Reenable this when we have modal windows.
+    // StackTransientParentsBelowModalWindow(active_view_);
+
+    active_view_->MoveToFront();
+  }
+
+  // TODO(erg): Individual windows can have a single ActivationChangeObserver
+  // set on them. In the aura version of this code, it sends an
+  // OnWindowActivated message to both the window that lost activation, and the
+  // window that gained it.
+
+  FOR_EACH_OBSERVER(FocusControllerObserver,
+                    focus_controller_observers_,
+                    OnViewActivated(active_view_,
+                                    view_tracker.Contains(lost_activation) ?
+                                    lost_activation : nullptr));
+}
+
+void FocusController::ViewLostFocusFromDispositionChange(
+    View* view,
+    View* next) {
+  // TODO(erg): We clear the modality state here in the aura::Window version of
+  // this class, and should probably do the same once we have modal windows.
+
+  // 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 (view == active_view_) {
+    View* next_activatable = rules_->GetNextActivatableView(view);
+    SetActiveView(nullptr, next_activatable);
+    if (!(active_view_ && active_view_->Contains(focused_view_)))
+      SetFocusedView(next_activatable);
+  } else if (view->Contains(focused_view_)) {
+    // Active window isn't changing, but focused window might be.
+    SetFocusedView(rules_->GetFocusableView(next));
+  }
+}
+
+void FocusController::ViewFocusedFromInputEvent(View* view) {
+  // 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_->CanFocusView(GetToplevelView(view)))
+    FocusView(view);
+}
+
+}  // namespace mojo