Wires up ShouldDescendIntoChildForEventHandling() for DesktopNativeWidgetAura

ui/views/widget/widget.h

 // 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.
 
 #ifndef UI_VIEWS_WIDGET_WIDGET_H_
 #define UI_VIEWS_WIDGET_WIDGET_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 697 matching lines @@
 
   // Reorders the widget's child NativeViews which are associated to the view
   // tree (eg via a NativeViewHost) to match the z-order of the views in the
   // view tree. The z-order of views with layers relative to views with
   // associated NativeViews is used to reorder the NativeView layers. This
   // method assumes that the widget's child layers which are owned by a view are
   // already in the correct z-order relative to each other and does no
   // reordering if there are no views with an associated NativeView.
   void ReorderNativeViews();
 
-  // Schedules an update to the root layers. The actual processing occurs when
-  // GetRootLayers() is invoked.
-  void UpdateRootLayers();
+  // Called by a View when the status of it's layer or one of the views
+  // descendants layer status changes.
+  void LayerTreeChanged();
 
   const NativeWidget* native_widget() const;
   NativeWidget* native_widget();
 
   internal::NativeWidgetPrivate* native_widget_private() {
     return native_widget_;
   }
   const internal::NativeWidgetPrivate* native_widget_private() const {
     return native_widget_;
   }
@@ skipping 78 matching lines @@
   void OnNativeWidgetEndUserBoundsChange() override;
   bool HasFocusManager() const override;
   void OnNativeWidgetPaint(const ui::PaintContext& context) override;
   int GetNonClientComponent(const gfx::Point& point) override;
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnMouseCaptureLost() override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
   bool ExecuteCommand(int command_id) override;
-  const std::vector<ui::Layer*>& GetRootLayers() override;
   bool HasHitTestMask() const override;
   void GetHitTestMask(gfx::Path* mask) const override;
   Widget* AsWidget() override;
   const Widget* AsWidget() const override;
   bool SetInitialFocus(ui::WindowShowState show_state) override;
+  bool ShouldDescendIntoChildForEventHandling(
+      ui::Layer* root_layer,
+      gfx::NativeView child,
+      ui::Layer* child_layer,
+      const gfx::Point& location) override;
 
   // Overridden from ui::EventSource:
   ui::EventProcessor* GetEventProcessor() override;
 
   // Overridden from FocusTraversable:
   FocusSearch* GetFocusSearch() override;
   FocusTraversable* GetFocusTraversableParent() override;
   View* GetFocusTraversableParentView() override;
 
   // Overridden from ui::NativeThemeObserver:
@@ skipping 13 matching lines @@
   // Notification that a drag will start. Default implementation does nothing.
   virtual void OnDragWillStart();
 
   // Notification that the drag performed by RunShellDrag() has completed.
   virtual void OnDragComplete();
 
  private:
   friend class ComboboxTest;
   friend class CustomButtonTest;
   friend class TextfieldTest;
+  friend class ViewAuraTest;
 
   // Persists the window's restored position and "show" state using the
   // window delegate.
   void SaveWindowPlacement();
 
   // Invokes SaveWindowPlacement() if the native widget has been initialized.
   // This is called at times when the native widget may not have been
   // initialized.
   void SaveWindowPlacementIfInitialized();
 
   // Sizes and positions the window just after it is created.
   void SetInitialBounds(const gfx::Rect& bounds);
 
   // Sizes and positions the frameless window just after it is created.
   void SetInitialBoundsForFramelessWindow(const gfx::Rect& bounds);
 
   // Returns the bounds and "show" state from the delegate. Returns true if
   // the delegate wants to use a specified bounds.
   bool GetSavedWindowPlacement(gfx::Rect* bounds,
                                ui::WindowShowState* show_state);
 
+  // Returns the Views whose layers are parented directly to the Widget's
+  // layer.
+  const View::Views& GetViewsWithLayers();
+
   internal::NativeWidgetPrivate* native_widget_;
 
   base::ObserverList<WidgetObserver> observers_;
 
   base::ObserverList<WidgetRemovalsObserver> removals_observers_;
 
   // Non-owned pointer to the Widget's delegate. If a NULL delegate is supplied
   // to Init() a default WidgetDelegate is created.
   WidgetDelegate* widget_delegate_;
 
@@ skipping 71 matching lines @@
   // The following are used to detect duplicate mouse move events and not
   // deliver them. Displaying a window may result in the system generating
   // duplicate move events even though the mouse hasn't moved.
   bool last_mouse_event_was_move_;
   gfx::Point last_mouse_event_position_;
 
   // True if event capture should be released on a mouse up event. Default is
   // true.
   bool auto_release_capture_;
 
-  // See description in GetRootLayers().
-  std::vector<ui::Layer*> root_layers_;
+  // See description in GetViewsWithLayers().
+  View::Views views_with_layers_;
 
-  // Is |root_layers_| out of date?
-  bool root_layers_dirty_;
+  // Does |views_with_layers_| need updating?
+  bool views_with_layers_dirty_;
 
   // True when window movement via mouse interaction with the frame should be
   // disabled.
   bool movement_disabled_;
 
   ScopedObserver<ui::NativeTheme, ui::NativeThemeObserver> observer_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(Widget);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_WIDGET_H_