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