Don't activate a window if screen is locked.

ui/aura/window.h

 // 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.
 
 #ifndef UI_AURA_WINDOW_H_
 #define UI_AURA_WINDOW_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 160 matching lines @@
 
   // Window takes ownership of the EventFilter.
   void SetEventFilter(EventFilter* event_filter);
   EventFilter* event_filter() { return event_filter_.get(); }
 
   // Add/remove observer.
   void AddObserver(WindowObserver* observer);
   void RemoveObserver(WindowObserver* observer);
 
   // When set to true, this Window will stop propagation of all events targeted
-  // at Windows below it in the z-order, but only if this Window has children.
+  // at Windows below it in the z-order, but only if this Window has children
+  // with the stops_event_propagation_ is true. If none of child has this
+  // property as true, then event will not be stopped.
   // This is used to implement lock-screen type functionality where we do not
   // want events to be sent to running logged-in windows when the lock screen is
   // displayed.
   void set_stops_event_propagation(bool stops_event_propagation) {
     stops_event_propagation_ = stops_event_propagation;
   }
+  bool stops_event_propagation() const {
+    return stops_event_propagation_;
+  }
 
   void set_ignore_events(bool ignore_events) { ignore_events_ = ignore_events; }
 
   // Returns true if relative-to-this-Window's-origin |local_point| falls
   // within this Window's bounds.
   bool ContainsPoint(const gfx::Point& local_point);
 
   // Returns true if the mouse pointer at relative-to-this-Window's-origin
   // |local_point| can trigger an event for this Window.
   // TODO(beng): A Window can supply a hit-test mask to cause some portions of
@@ skipping 15 matching lines @@
   // Claims or relinquishes the claim to focus.
   void Focus();
   void Blur();
 
   // Returns true if the Window is currently the focused window.
   bool HasFocus() const;
 
   // Returns true if the Window can be focused.
   virtual bool CanFocus() const;
 
+  // Returns true if the Window can receive events.
+  virtual bool CanReceiveEvents() const;
+
   // Returns the FocusManager for the Window, which may be attached to a parent
   // Window. Can return NULL if the Window has no FocusManager.
   virtual internal::FocusManager* GetFocusManager();
   virtual const internal::FocusManager* GetFocusManager() const;
 
   // Does a mouse capture on the window. This does nothing if the window isn't
   // showing (VISIBILITY_SHOWN) or isn't contained in a valid window hierarchy.
   void SetCapture();
 
   // Releases a mouse capture.
@@ skipping 10 matching lines @@
   void SetIntProperty(const char* name, int value);
 
   // Returns the window property for given |name|.  Returns NULL or 0 if
   // the property does not exist.
   // TODO(oshima): Returning 0 for non existing property is problematic.
   // Fix ViewProp to be able to tell if the property exists and
   // change it to -1.
   void* GetProperty(const char* name) const;
   int GetIntProperty(const char* name) const;
 
+  // This window is currently stopping event propagation for any windows behind
+  // it in the z-order.
+  bool StopsEventPropagation() const;
+
  protected:
   // Returns the root window or NULL if we aren't yet attached to the root
   // window.
   virtual RootWindow* GetRootWindow();
 
   // Called when the |window| is detached from the root window by being removed
   // from its parent.
   virtual void WindowDetachedFromRootWindow(aura::Window* window);
 
  private:
   friend class LayoutManager;
 
   // Changes the bounds of the window without condition.
   void SetBoundsInternal(const gfx::Rect& new_bounds);
 
   // Updates the visible state of the layer, but does not make visible-state
   // specific changes. Called from Show()/Hide().
   void SetVisible(bool visible);
 
   // Schedules a paint for the Window's entire bounds.
   void SchedulePaint();
 
-  // This window is currently stopping event propagation for any windows behind
-  // it in the z-order.
-  bool StopsEventPropagation() const;
-
   // Gets a Window (either this one or a subwindow) containing |local_point|.
   // If |return_tightest| is true, returns the tightest-containing (i.e.
   // furthest down the hierarchy) Window containing the point; otherwise,
   // returns the loosest.  If |for_event_handling| is true, then hit-test masks
   // and StopsEventPropagation() are honored; otherwise, only bounds checks are
   // performed.
   Window* GetWindowForPoint(const gfx::Point& local_point,
                             bool return_tightest,
                             bool for_event_handling);
 
   // Called when this window's parent has changed.
   void OnParentChanged();
 
   // Called when this window's stacking order among its siblings is changed.
   void OnStackingChanged();
 
   // Overridden from ui::LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
 
   // Updates the layer name with a name based on the window's name and id.
   void UpdateLayerName(const std::string& name);
 
+  // Returns true if the Window is behind a window that stops event propagation.
+  bool IsBehindStopEventsWindow() const;
+
   client::WindowType type_;
 
   WindowDelegate* delegate_;
 
   scoped_ptr<ui::Layer> layer_;
 
   // The Window's parent.
   Window* parent_;
 
   // Child windows. Topmost is last.
@@ skipping 29 matching lines @@
   // TODO(oshima): Consolidcate ViewProp and aura::window property
   // implementation.
   std::map<const char*, void*> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_H_