Remove stops_event_propagation from Window, since it's broken.

ui/aura/window.cc

 // Copyright (c) 2012 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"
 #include "base/string_util.h"
+#include "ui/aura/client/event_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/animation/multi_animation.h"
@@ skipping 24 matching lines @@
 Window::Window(WindowDelegate* delegate)
     : type_(client::WINDOW_TYPE_UNKNOWN),
       delegate_(delegate),
       layer_(NULL),
       parent_(NULL),
       transient_parent_(NULL),
       visible_(false),
       id_(-1),
       transparent_(false),
       user_data_(NULL),
-      stops_event_propagation_(false),
       ignore_events_(false),
       hit_test_bounds_override_outer_(0),
       hit_test_bounds_override_inner_(0) {
 }
 
 Window::~Window() {
   // layer_ can be NULL if Init() wasn't invoked, which can happen
   // only in tests.
   if (layer_)
     layer_->SuppressPaint();
@@ skipping 375 matching lines @@
 }
 
 // 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();
+
+  // The client may forbid certain windows from receiving focus at a given point
+  // in time.
+  client::EventClient* client = client::GetEventClient(GetRootWindow());
+  if (client && !client->CanProcessEventsWithinSubtree(this))
+    return false;
+
+  return parent_->CanFocus();
 }
 
 bool Window::CanReceiveEvents() const {
-  return parent_ && IsVisible() && !IsBehindStopEventsWindow() &&
-      parent_->CanReceiveEvents();
+  // The client may forbid certain windows from receiving events at a given
+  // point in time.
+  client::EventClient* client = client::GetEventClient(GetRootWindow());
+  if (client && !client->CanProcessEventsWithinSubtree(this))
+    return false;
+
+  return parent_ && IsVisible() && 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 15 matching lines @@
     return;
 
   root_window->ReleaseCapture(this);
 }
 
 bool Window::HasCapture() {
   RootWindow* root_window = GetRootWindow();
   return root_window && root_window->capture_window() == this;
 }
 
-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();
-}
-
 void Window::SuppressPaint() {
   layer_->SuppressPaint();
 }
 
 // {Set,Get,Clear}Property are implemented in window_property.h.
 
 void Window::SetNativeWindowProperty(const char* key, void* value) {
   SetPropertyInternal(
       key, key, NULL, reinterpret_cast<intptr_t>(value), 0);
 }
@@ skipping 134 matching lines @@
       return delegate_ ? this : NULL;
   }
 
   if (!return_tightest && delegate_)
     return this;
 
   for (Windows::const_reverse_iterator it = children_.rbegin(),
            rend = children_.rend();
        it != rend; ++it) {
     Window* child = *it;
+
+    if (for_event_handling) {
+      // The client may not allow events to be processed by certain subtrees.
+      client::EventClient* client = client::GetEventClient(GetRootWindow());
+      if (client && !client->CanProcessEventsWithinSubtree(child))
+        continue;
+    }
+
+    // We don't process events for invisible windows or those that have asked
+    // to ignore events.
     if (!child->IsVisible() || (for_event_handling && child->ignore_events_))
       continue;
 
     gfx::Point point_in_child_coords(local_point);
     Window::ConvertPointToWindow(this, child, &point_in_child_coords);
     Window* match = child->GetWindowForPoint(point_in_child_coords,
                                              return_tightest,
                                              for_event_handling);
     if (match)
       return match;
-
-    if (for_event_handling && child->StopsEventPropagation())
-      break;
   }
 
   return delegate_ ? this : NULL;
 }
 
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
@@ skipping 114 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