[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 "chromecast/graphics/cast_focus_client_aura.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 chromecast {
 
+// An ui::EventTarget that ignores events.
+class CastEventIgnorer : public ui::EventTargeter {
+ public:
+  ~CastEventIgnorer() override;
+
+  // ui::EventTargeter implementation:
+  ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+                                      ui::Event* event) override;
+  ui::EventTarget* FindNextBestTarget(ui::EventTarget* previous_target,
+                                      ui::Event* event) override;
+};
+
+CastEventIgnorer::~CastEventIgnorer() {}
+
+ui::EventTarget* CastEventIgnorer::FindTargetForEvent(ui::EventTarget* root,
+                                                      ui::Event* event) {
+  return nullptr;
+}
+
+ui::EventTarget* CastEventIgnorer::FindNextBestTarget(
+    ui::EventTarget* previous_target,
+    ui::Event* event) {
+  return nullptr;
+}
+
 // 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;
 
  private:
   const bool enable_input_;
 
   DISALLOW_COPY_AND_ASSIGN(CastWindowTreeHost);
 };
 
 CastWindowTreeHost::CastWindowTreeHost(bool enable_input,
                                        const gfx::Rect& bounds)
-    : WindowTreeHostPlatform(bounds), enable_input_(enable_input) {}
+    : WindowTreeHostPlatform(bounds), enable_input_(enable_input) {
+  if (!enable_input) {
+    window()->SetEventTargeter(
+        std::unique_ptr<ui::EventTargeter>(new CastEventIgnorer));
+  }
+}
 
 CastWindowTreeHost::~CastWindowTreeHost() {}
 
 void CastWindowTreeHost::DispatchEvent(ui::Event* event) {
   if (!enable_input_) {
     return;
   }
 
   if (event->IsKeyEvent()) {
     // Convert a RawKeyDown into a character insertion; otherwise
@@ skipping 81 matching lines @@
   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);
 
+  focus_client_.reset(new CastFocusClientAura());
+  aura::client::SetFocusClient(window_tree_host_->window(),
+                               focus_client_.get());
   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;
   }
   CastVSyncSettings::GetInstance()->RemoveObserver(this);
   capture_client_.reset();
+  aura::client::SetFocusClient(window_tree_host_->window(), nullptr);
+  focus_client_.reset();
   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) {

[sadrul, 2017/01/26 01:50:10]

auto* other : windows

[Joshua LeVasseur, 2017/01/26 02:51:01]

Done.

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

[sadrul, 2017/01/26 01:50:10]

Where in the code do you assign the window ids? I assume you want to use
CastWindowManager::WindowId, but I couldn't find where it's set from a quick
look.

Note that aura only sets the default id to all windows during creation, and it
is upto the client to explicitly set a different id (if desired). So unless some
code in chromecast is setting the id, this wouldn't work very well.

[Joshua LeVasseur, 2017/01/26 02:51:01]

Some future code changes, which will bring in additional windows, will assign
the IDs.  I've tried to make the code handle the default ID gracefully, so that
it isn't necessary to assign an ID for the bottom-most (default position)
windows.  If an overlay is desired, then the ID will be necessary.  If the
aura::Window::kInitialId ever changes, then things will stop working, so I've
added another unit test that ensures that the BOTTOM window ID always matches
the default aura::Window::kInitialId.  Note that cast_window_manager.h, which
declares the window IDs, can't have a dependency on ui/aura/window.h, because
cast_window_manager.h can be used in code that doesn't use Aura (e.g., Android).
 But the Aura-based code is the only code concerned with z-order at the moment.

+      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);
 }
 
 }  // namespace chromecast