[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"
 
+namespace {
+static bool kFocusFollowsVisibility = true;

[derekjchow1, 2017/01/19 18:12:13]

static keyword isn't needed here. const keyword should be.

[Joshua LeVasseur, 2017/01/19 19:35:25]

Done.

+}
+
 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.
+  aura::Window::Windows windows = parent->children();
+  aura::Window* above = nullptr;
+  aura::Window* below = nullptr;
+  for (auto&& other : windows) {

[derekjchow1, 2017/01/19 18:12:13]

Could this be done with std::reduce?

http://en.cppreference.com/w/cpp/algorithm/reduce

Does it look cleaner?

[Joshua LeVasseur, 2017/01/19 19:35:25]

I don't see it ... I'd need an example, but I don't see std::reduce used
anywhere in the code base on cs.chromium.org.

+    if (other == child) {
+      continue;
+    } else if ((other->id() < child->id()) &&

[derekjchow1, 2017/01/19 18:12:13]

No need for else case after a continue statement.

[Joshua LeVasseur, 2017/01/19 19:35:25]

Done.

+               (!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);
 }
 
+//////////////////////////////////////////////////////////////////////

[derekjchow1, 2017/01/19 18:12:13]

I don't think this comment is needed in a .cc file.

[Joshua LeVasseur, 2017/01/19 19:35:25]

Done.

+// Implementation for aura::WindowObserver
+
+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 top-level: " << top_level->id() << ": "
+            << top_level->GetName() << ", window: " << window->id() << ": "
+            << window->GetName();
+
+  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 top-level: " << top_level->id() << ": "
+                << top_level->GetName() << ", window: " << window->id() << ": "
+                << window->GetName();
+    } else {
+      ++iter;
+    }
+  }
+
+  if (was_focused) {
+    UpdateWindowFocus(focused_window_);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Implementation for aura::client::FocusClient
+
+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 top-level: " << top_level->id() << ": "

[derekjchow1, 2017/01/19 18:12:13]

This is duplicated a lot, could you turn this into a helper function or macro?

[Joshua LeVasseur, 2017/01/19 19:35:25]

Done.

+              << top_level->GetName() << ", window: " << window->id() << ": "
+              << window->GetName();
+    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 top-level: " << top_level->id() << ": "
+              << top_level->GetName() << ", window: " << window->id() << ": "
+              << window->GetName();
+  }
+
+  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) {

[derekjchow1, 2017/01/19 18:12:13]

Why is this here? A few lines above make focused_window_ == window, so this
should always be true. Can OnWindowFocused function change focused_window_?

[Joshua LeVasseur, 2017/01/19 19:35:25]

Yes, OnWindowFocused can change focused_window_.  This needs a comment.

+      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) {
+        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) {
+        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