Don't activate a window if screen is locked.

ui/aura/window.cc

 // Copyright (c) 2011 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 330 matching lines @@
 void Window::Blur() {
   DCHECK(GetFocusManager());
   GetFocusManager()->SetFocusedWindow(NULL);
 }
 
 bool Window::HasFocus() const {
   const internal::FocusManager* focus_manager = GetFocusManager();
   return focus_manager ? focus_manager->IsFocusedWindow(this) : false;
 }
 
-// For a given window, we determine its focusability by inspecting each sibling
-// after it (i.e. drawn in front of it in the z-order) to see if it stops
-// propagation of events that would otherwise be targeted at windows behind it.
-// We then perform this same check on every window up to the root.
+// For a given window, we determine its focusability and ability to
+// receive events by inspecting each sibling after it (i.e. drawn in
+// front of it in the z-order) to see if it stops propagation of
+// events that would otherwise be targeted at windows behind it.  We
+// then perform this same check on every window up to the root.
 bool Window::CanFocus() const {
   if (!IsVisible() || !parent_ || (delegate_ && !delegate_->CanFocus()))
     return false;
+  return !IsBehindStopEventsWindow() && parent_->CanFocus();
+}
 
-  Windows::const_iterator i = std::find(parent_->children().begin(),
-                                        parent_->children().end(),
-                                        this);
-  for (++i; i != parent_->children().end(); ++i) {
-    if ((*i)->StopsEventPropagation())
-      return false;
-  }
-  return parent_->CanFocus();
+bool Window::CanReceiveEvents() const {

[sky, 2012/01/12 21:11:36]

Do we really need this? Can we instead use CanFocus?

[oshima, 2012/01/12 21:32:50]

I needed separate method because non focusable window (which is checked by
delegate_->CanFocus()), can be activated.

+  return parent_ && IsVisible() && !IsBehindStopEventsWindow() &&
+      parent_->CanReceiveEvents();
 }
 
 internal::FocusManager* Window::GetFocusManager() {
   return const_cast<internal::FocusManager*>(
       static_cast<const Window*>(this)->GetFocusManager());
 }
 
 const internal::FocusManager* Window::GetFocusManager() const {
   return parent_ ? parent_->GetFocusManager() : NULL;
 }
@@ skipping 41 matching lines @@
   if (iter == prop_map_.end())
     return NULL;
   return iter->second;
 }
 
 int Window::GetIntProperty(const char* name) const {
   return static_cast<int>(reinterpret_cast<intptr_t>(
       GetProperty(name)));
 }
 
+bool Window::StopsEventPropagation() const {
+  if (!stops_event_propagation_ || children_.empty())
+    return false;
+  aura::Window::Windows::const_iterator it =
+      std::find_if(children_.begin(), children_.end(),
+                   std::mem_fun(&aura::Window::IsVisible));
+  return it != children_.end();
+}
+
 RootWindow* Window::GetRootWindow() {
   return parent_ ? parent_->GetRootWindow() : NULL;
 }
 
 void Window::WindowDetachedFromRootWindow(aura::Window* window) {
 }
 
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   gfx::Rect actual_new_bounds(new_bounds);
 
@@ skipping 42 matching lines @@
   if (parent_ && parent_->layout_manager_.get())
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanged(this, visible));
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
-bool Window::StopsEventPropagation() const {
-  return stops_event_propagation_ && !children_.empty();
-}
-
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
                                   bool for_event_handling) {
   if (!IsVisible())
     return NULL;
 
   if ((for_event_handling && !HitTest(local_point)) ||
       (!for_event_handling && !ContainsPoint(local_point)))
     return NULL;
 
@@ skipping 45 matching lines @@
 
   if (id_ != -1) {
     char id_buf[10];
     base::snprintf(id_buf, sizeof(id_buf), " %d", id_);
     layer_name.append(id_buf);
   }
   layer()->set_name(layer_name);
 #endif
 }
 
+bool Window::IsBehindStopEventsWindow() const {
+  Windows::const_iterator i = std::find(parent_->children().begin(),
+                                        parent_->children().end(),
+                                        this);
+  for (++i; i != parent_->children().end(); ++i) {
+    if ((*i)->StopsEventPropagation())
+      return true;
+  }
+  return false;
+}
+
 }  // namespace aura