[Chromecast] Add support for z-order and window focus.

chromecast/graphics/cast_window_manager_aura.cc

 // Copyright 2017 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 "chromecast/graphics/cast_window_manager_aura.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/default_capture_client.h"
+#include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host_platform.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
+#define LOG_WINDOW_INFO(top_level, window)                             \
+  "top-level: " << (top_level)->id() << ": " << (top_level)->GetName() \
+                << ", window: " << (window)->id() << ": "              \
+                << (window)->GetName()
+
+namespace {
+const bool kFocusFollowsVisibility = true;
+}
+
 namespace chromecast {
 
 // An aura::WindowTreeHost that correctly converts input events.
 class CastWindowTreeHost : public aura::WindowTreeHostPlatform {
  public:
   CastWindowTreeHost(bool enable_input, const gfx::Rect& bounds);
   ~CastWindowTreeHost() override;
 
   // aura::WindowTreeHostPlatform implementation:
   void DispatchEvent(ui::Event* event) override;
@@ skipping 73 matching lines @@
   SetChildBoundsDirect(child, requested_bounds);
 }
 
 // static
 std::unique_ptr<CastWindowManager> CastWindowManager::Create(
     bool enable_input) {
   return base::WrapUnique(new CastWindowManagerAura(enable_input));
 }
 
 CastWindowManagerAura::CastWindowManagerAura(bool enable_input)
-    : enable_input_(enable_input) {}
+    : enable_input_(enable_input), focused_window_(nullptr) {}
 
 CastWindowManagerAura::~CastWindowManagerAura() {
   TearDown();
 }
 
 void CastWindowManagerAura::Setup() {
   if (window_tree_host_) {
     return;
   }
   DCHECK(display::Screen::GetScreen());
 
   ui::InitializeInputMethodForTesting();
 
   gfx::Size display_size =
       display::Screen::GetScreen()->GetPrimaryDisplay().GetSizeInPixel();
   LOG(INFO) << "Starting window manager, screen size: " << display_size.width()
             << "x" << display_size.height();
   CHECK(aura::Env::GetInstance());
   window_tree_host_.reset(
       new CastWindowTreeHost(enable_input_, gfx::Rect(display_size)));
   window_tree_host_->InitHost();
   window_tree_host_->window()->SetLayoutManager(new CastLayoutManager());
 
   // Allow seeing through to the hardware video plane:
   window_tree_host_->compositor()->SetHostHasTransparentBackground(true);
   window_tree_host_->compositor()->SetBackgroundColor(SK_ColorTRANSPARENT);
 
+  aura::client::SetFocusClient(window_tree_host_->window(), this);
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(window_tree_host_->window()));
 
   CastVSyncSettings::GetInstance()->AddObserver(this);
   window_tree_host_->compositor()->SetAuthoritativeVSyncInterval(
       CastVSyncSettings::GetInstance()->GetVSyncInterval());
 
   window_tree_host_->Show();
 }
 
 void CastWindowManagerAura::TearDown() {
   if (!window_tree_host_) {
     return;
   }
+  focused_window_ = nullptr;
   CastVSyncSettings::GetInstance()->RemoveObserver(this);
   capture_client_.reset();
+  aura::client::SetFocusClient(window_tree_host_->window(), nullptr);
   window_tree_host_.reset();
 }
 
 void CastWindowManagerAura::AddWindow(gfx::NativeView child) {
   LOG(INFO) << "Adding window: " << child->id() << ": " << child->GetName();
   Setup();
 
   DCHECK(child);
   aura::Window* parent = window_tree_host_->window();
   if (!parent->Contains(child)) {
     parent->AddChild(child);
   }
 
-  parent->StackChildAtTop(child);
+  // Determine z-order relative to existing windows.

[halliwell, 2017/01/19 20:49:17]

This is ordering windows by ID?  Is the assumption that we use the WindowId enum
to set window IDs?

[Joshua LeVasseur, 2017/01/23 23:38:32]

Yes, we use this enum for setting window IDs.  If you don't set the ID, it just
keeps the default of -1.

+  aura::Window::Windows windows = parent->children();
+  aura::Window* above = nullptr;
+  aura::Window* below = nullptr;
+  for (auto&& other : windows) {
+    if (other == child) {
+      continue;
+    }
+    if ((other->id() < child->id()) && (!below || other->id() > below->id())) {
+      below = other;
+    } else if ((other->id() > child->id()) &&
+               (!above || other->id() < above->id())) {
+      above = other;
+    }
+  }
+
+  // Adjust the z-order of the new child window.
+  if (above) {
+    parent->StackChildBelow(child, above);
+  } else if (below) {
+    parent->StackChildAbove(child, below);
+  } else {
+    parent->StackChildAtBottom(child);
+  }
   child->SetBounds(window_tree_host_->window()->bounds());
 }
 
 void CastWindowManagerAura::OnVSyncIntervalChanged(base::TimeDelta interval) {
   DCHECK(window_tree_host_.get());
   window_tree_host_->compositor()->SetAuthoritativeVSyncInterval(interval);
 }
 
+void CastWindowManagerAura::OnWindowVisibilityChanged(aura::Window* window,
+                                                      bool visible) {
+  if (!kFocusFollowsVisibility) {
+    return;
+  }
+  if (!visible && (window == focused_window_)) {
+    UpdateWindowFocus(focused_window_);
+  } else if (visible) {
+    UpdateWindowFocus(nullptr);
+  }
+}
+
+void CastWindowManagerAura::OnWindowDestroying(aura::Window* window) {
+  aura::Window* top_level = GetTopLevelWindow(window);
+  DCHECK(top_level);
+  LOG(INFO) << "Removing window, " << LOG_WINDOW_INFO(top_level, window);
+
+  auto iter =
+      std::find(focusable_windows_.begin(), focusable_windows_.end(), window);
+  if (iter != focusable_windows_.end()) {
+    focusable_windows_.erase(iter);
+    window->RemoveObserver(this);
+  }
+  if (window == focused_window_) {
+    UpdateWindowFocus(focused_window_);
+  }
+}
+
+void CastWindowManagerAura::OnWindowHierarchyChanging(
+    const HierarchyChangeParams& params) {
+  if (params.new_parent &&
+      (aura::client::GetFocusClient(params.new_parent) == this)) {
+    return;
+  }
+
+  auto iter = focusable_windows_.begin();
+  bool was_focused = false;
+  while (iter != focusable_windows_.end()) {
+    aura::Window* window = *iter;
+    if (params.target == window || params.target->Contains(window)) {
+      window->RemoveObserver(this);
+      was_focused |= window == focused_window_;
+      iter = focusable_windows_.erase(iter);
+
+      aura::Window* top_level = GetTopLevelWindow(window);
+      DCHECK(top_level);
+      LOG(INFO) << "Dropping window, " << LOG_WINDOW_INFO(top_level, window);
+    } else {
+      ++iter;
+    }
+  }

[halliwell, 2017/01/19 20:49:17]

All of these focus change logic functions are kind of hard to follow ... I mean
the logic is fine but I have no idea what the high level goals are or how to
tell if there are bugs.

It would be best to add some tests that set out the expected behaviour and allow
people to update this code with confidence.

Some high level comments on each function would be useful as well.

[Joshua LeVasseur, 2017/01/23 23:38:32]

Done.

+
+  if (was_focused) {
+    UpdateWindowFocus(focused_window_);
+  }
+}
+
+void CastWindowManagerAura::AddObserver(
+    aura::client::FocusChangeObserver* observer) {
+  focus_observers_.AddObserver(observer);
+}
+
+void CastWindowManagerAura::RemoveObserver(
+    aura::client::FocusChangeObserver* observer) {
+  focus_observers_.RemoveObserver(observer);
+}
+
+void CastWindowManagerAura::FocusWindow(aura::Window* window) {
+  if (window) {
+    if (!window->CanFocus()) {
+      return;
+    }
+    aura::Window* top_level = GetTopLevelWindow(window);
+    DCHECK(top_level);
+    LOG(INFO) << "Requesting focus for " << LOG_WINDOW_INFO(top_level, window);
+    auto iter =
+        std::find(focusable_windows_.begin(), focusable_windows_.end(), window);
+    if (iter == focusable_windows_.end()) {
+      window->AddObserver(this);
+      focusable_windows_.push_back(window);
+    }
+  }
+
+  UpdateWindowFocus(nullptr);
+}
+
+void CastWindowManagerAura::ResetFocusWithinActiveWindow(aura::Window* window) {
+  // Sets focus to |window| if it's within the active window (a child of the
+  // focused window).
+  if (focused_window_ && focused_window_->Contains(window)) {
+    FocusWindow(window);
+  }
+}
+
+aura::Window* CastWindowManagerAura::GetFocusedWindow() {
+  return focused_window_;
+}
+
+void CastWindowManagerAura::UpdateWindowFocus(aura::Window* skip) {
+  aura::Window* window = GetWindowToFocus(skip);
+  if (window == focused_window_) {
+    return;
+  }
+
+  if (window) {
+    aura::Window* top_level = GetTopLevelWindow(window);
+    DCHECK(top_level);
+    LOG(INFO) << "Switching focus to " << LOG_WINDOW_INFO(top_level, window);
+  }
+
+  aura::Window* unfocus_window = focused_window_;
+  focused_window_ = window;
+
+  for (aura::client::FocusChangeObserver& observer : focus_observers_) {
+    observer.OnWindowFocused(focused_window_, unfocus_window);
+    if (focused_window_ != window) {
+      // The observer changed focused_window_.
+      return;
+    }
+  }
+
+  if (unfocus_window) {
+    aura::client::FocusChangeObserver* focus_observer =
+        aura::client::GetFocusChangeObserver(unfocus_window);
+    if (focus_observer) {
+      focus_observer->OnWindowFocused(focused_window_, unfocus_window);
+      if (focused_window_ != window) {
+        // The observer changed focused_window_.
+        return;
+      }
+    }
+  }
+  if (focused_window_) {
+    aura::client::FocusChangeObserver* focus_observer =
+        aura::client::GetFocusChangeObserver(focused_window_);
+    if (focus_observer) {
+      focus_observer->OnWindowFocused(focused_window_, unfocus_window);
+      if (focused_window_ != window) {
+        // The observer changed focused_window_.
+        return;
+      }
+    }
+  }
+}
+
+aura::Window* CastWindowManagerAura::GetWindowToFocus(aura::Window* skip) {
+  aura::Window* next = nullptr;
+  aura::Window* next_top_level = nullptr;
+  for (auto iter = focusable_windows_.begin(); iter != focusable_windows_.end();
+       ++iter) {
+    aura::Window* window = *iter;
+    if (window == skip || !window->CanFocus() ||
+        (kFocusFollowsVisibility && !window->IsVisible())) {
+      continue;
+    }
+
+    aura::Window* top_level = GetTopLevelWindow(window);
+    DCHECK(window_tree_host_->window()->Contains(top_level));
+    if (top_level && (!next || top_level->id() >= next_top_level->id())) {
+      next = window;
+      next_top_level = top_level;
+    }
+  }
+  return next;
+}
+
+aura::Window* CastWindowManagerAura::GetTopLevelWindow(aura::Window* window) {
+  while (window->parent() && window->parent() != window_tree_host_->window()) {
+    window = window->parent();
+  }
+  return window;
+}
+
 }  // namespace chromecast