Lock screen for Chrome-Athena

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/input/public/accelerator_manager.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "athena/util/container_priorities.h"
 #include "athena/util/fill_layout_manager.h"
@@ skipping 136 matching lines @@
       : container_(container) {
     container_->AddObserver(this);
   }
 
   virtual ~AthenaEventTargeter() {
     // Removed before the container is removed.
     if (container_)
       container_->RemoveObserver(this);
   }
 
+  void SetPreviousEventTargeter(scoped_ptr<ui::EventTargeter> targeter) {
+    previous_root_event_targeter_ = targeter.Pass();
+  }
+
  private:
   // aura::WindowTargeter:
   virtual bool SubtreeCanAcceptEvent(
       ui::EventTarget* target,
       const ui::LocatedEvent& event) const override {
     aura::Window* window = static_cast<aura::Window*>(target);
     const aura::Window::Windows& containers =
         container_->GetRootWindow()->children();
     aura::Window::Windows::const_iterator iter =
         std::find(containers.begin(), containers.end(), container_);
     DCHECK(iter != containers.end());
     for (; iter != containers.end(); ++iter) {
       if ((*iter)->Contains(window))
         return true;
     }
     return false;
   }
 
   // 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>());
+    root_window->SetEventTargeter(previous_root_event_targeter_.Pass());
   }
 
   aura::Window* container_;
+  scoped_ptr<ui::EventTargeter> previous_root_event_targeter_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaEventTargeter);
 };
 
 class ScreenManagerImpl : public ScreenManager {
  public:
   explicit ScreenManagerImpl(aura::Window* root_window);
   virtual ~ScreenManagerImpl();
 
   void Init();
@@ skipping 118 matching lines @@
   container->SetProperty(kContainerParamsKey, new ContainerParams(params));
 
   // 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.
   if (params.grab_inputs) {
     DCHECK(std::find_if(children.begin(), children.end(), &GrabsInput)
            == children.end())
         << "input has already been grabbed by another container";
-    root_window_->SetEventTargeter(
-        scoped_ptr<ui::EventTargeter>(new AthenaEventTargeter(container)));
+    AthenaEventTargeter* athena_event_targeter =
+        new AthenaEventTargeter(container);
+    athena_event_targeter->SetPreviousEventTargeter(
+        root_window_->SetEventTargeter(
+            scoped_ptr<ui::EventTargeter>(athena_event_targeter)));
   }
 
   root_window_->AddChild(container);
 
   aura::Window::Windows::const_iterator iter =
       std::find_if(children.begin(),
                    children.end(),
                    HigherPriorityFinder(params.z_order_priority));
   if (iter != children.end())
     root_window_->StackChildBelow(container, *iter);
@@ skipping 45 matching lines @@
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 }  // namespace athena