Introduce 'grab_inputs' property for athena container.

athena/screen/screen_manager_impl.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 "athena/screen/public/screen_manager.h"
 
 #include "athena/common/fill_layout_manager.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/background_controller.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
+#include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
 
 namespace athena {
 namespace {
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(ScreenManager::ContainerParams,
                                  kContainerParamsKey,
                                  NULL);
 
 ScreenManager* instance = NULL;
 
 class AthenaFocusRules : public wm::BaseFocusRules {
  public:
   AthenaFocusRules() {}
   virtual ~AthenaFocusRules() {}
 
   // wm::BaseFocusRules:
   virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
     ScreenManager::ContainerParams* params =
         window->GetProperty(kContainerParamsKey);
     return params && params->can_activate_children;
   }
+  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE {
+    // Check if other containers have 'grab_inputs' fields.
+    bool other_has_grab = false;
+    if (window) {
+      const aura::Window::Windows& containers =
+          window->GetRootWindow()->children();
+      for (size_t i = 0; i < containers.size(); ++i) {
+        ScreenManager::ContainerParams* params =
+            containers[i]->GetProperty(kContainerParamsKey);
+        if (!containers[i]->Contains(window) && params && params->grab_inputs) {
+          other_has_grab = true;
+          break;
+        }
+      }
+    }
+    return !other_has_grab && BaseFocusRules::CanActivateWindow(window);
+  }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AthenaFocusRules);
 };
 
 class AthenaWindowTreeClient : public aura::client::WindowTreeClient {
  public:
   explicit AthenaWindowTreeClient(aura::Window* container)
       : container_(container) {}
 
@@ skipping 41 matching lines @@
 
   virtual void SetBounds(aura::Window* window,
                          const gfx::Rect& bounds,
                          const gfx::Display& display) OVERRIDE {
     window->SetBounds(bounds);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AthenaScreenPositionClient);
 };
 
+class AthenaEventTargeter : public aura::WindowTargeter,
+                            public aura::WindowObserver {
+ public:
+  AthenaEventTargeter(aura::Window* container)
+      : container_(container) {
+    container_->AddObserver(this);
+  }
+
+  virtual ~AthenaEventTargeter() {
+    // Removed before the container is removed.
+    if (container_)
+      container_->RemoveObserver(this);
+  }
+
+ private:
+  // aura::WindowTargeter:
+  virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+                                              ui::Event* event) OVERRIDE {
+    ui::EventTarget* target =
+        aura::WindowTargeter::FindTargetForEvent(root, event);
+    return container_->Contains(static_cast<aura::Window*>(target)) ?

[oshima, 2014/07/23 23:24:35]

We need to allow a container that has higher z-order so that virtual keyboard
still work on lock screen.

[Jun Mukai, 2014/07/24 17:52:02]

Done.  Also added some tests.

+        target : NULL;
+  }
+
+  // aura::WindowObserver:
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+    aura::Window* root_window = container_->GetRootWindow();
+    DCHECK_EQ(window, container_);
+    DCHECK_EQ(
+        this, static_cast<ui::EventTarget*>(root_window)->GetEventTargeter());
+
+    container_->RemoveObserver(this);
+    container_ = NULL;
+
+    // This will remove myself.
+    root_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>());
+  }
+
+  aura::Window* container_;
+
+  DISALLOW_COPY_AND_ASSIGN(AthenaEventTargeter);
+};
+
 class ScreenManagerImpl : public ScreenManager {
  public:
   explicit ScreenManagerImpl(aura::Window* root_window);
   virtual ~ScreenManagerImpl();
 
   void Init();
 
  private:
   // ScreenManager:
   virtual aura::Window* CreateDefaultContainer(
@@ skipping 39 matching lines @@
 
   return container;
 }
 
 aura::Window* ScreenManagerImpl::CreateContainer(
     const ContainerParams& params) {
   aura::Window* container = new aura::Window(NULL);
   container->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   container->SetName(params.name);
   root_window_->AddChild(container);
+  // If another container is already grabbing the input, SetEventTargeter
+  // implicitly release the grabbing and remove the EventTargeter instance.
+  // TODO(mukai|oshima): think about the ideal behavior of multiple grabbing
+  // and implement it.

[oshima, 2014/07/23 23:24:35]

Can you add check to make sure no other containers have this parameter set for
the time being?

[Jun Mukai, 2014/07/24 17:52:02]

Done.

+  if (params.grab_inputs) {
+    root_window_->SetEventTargeter(
+        scoped_ptr<ui::EventTargeter>(new AthenaEventTargeter(container)));
+  }
   container->Show();
   container->SetProperty(kContainerParamsKey, new ContainerParams(params));
   return container;
 }
 
 void ScreenManagerImpl::SetBackgroundImage(const gfx::ImageSkia& image) {
   background_controller_->SetImage(image);
 }
 
 ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
     : root_window_(root_window) {
   DCHECK(root_window_);
   DCHECK(!instance);
   instance = this;
 }
 
 ScreenManagerImpl::~ScreenManagerImpl() {
   aura::client::SetScreenPositionClient(root_window_, NULL);
   aura::client::SetWindowTreeClient(root_window_, NULL);
   instance = NULL;
 }
 
 }  // namespace
 
 ScreenManager::ContainerParams::ContainerParams(const std::string& n)
     : name(n),
-      can_activate_children(false) {
+      can_activate_children(false),
+      grab_inputs(false) {
 }
 
 // static
 ScreenManager* ScreenManager::Create(aura::Window* root_window) {
   (new ScreenManagerImpl(root_window))->Init();
   DCHECK(instance);
   return instance;
 }
 
 // static
 ScreenManager* ScreenManager::Get() {
   DCHECK(instance);
   return instance;
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 // static
 wm::FocusRules* ScreenManager::CreateFocusRules() {
   return new AthenaFocusRules();
 }
 
 }  // namespace athena