Get event targetting working for mouse events.

mojo/services/window_manager/view_target.h

 // 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.
 
 #ifndef MOJO_SERVICES_WINDOW_MANAGER_VIEW_TARGET_H_
 #define MOJO_SERVICES_WINDOW_MANAGER_VIEW_TARGET_H_
 
+#include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "ui/events/event_target.h"
 
+namespace gfx {
+class Point;
+class Rect;
+class Vector2d;
+}
+
 namespace ui {
 class EventTargeter;
 }
 
 namespace mojo {
 
 class View;
 class ViewTargeter;
 class WindowManagerApp;
 
-// A wrapper class around mojo::View. We maintain a shadow tree of ViewTargets,
-// which mirrors the main View tree. The ViewTarget tree wraps mojo::View
-// because we can't subclass View to implement the event targeting interfaces.
-class ViewTarget : public ui::EventTarget {
+// A wrapper class around mojo::View; we can't subclass View to implement the
+// event targeting interfaces, so we create a separate object which observes
+// the View and ties its lifetime to it.
+//
+// Instead of maintaining a shadow tree, we keep a static mapping between a

[sky, 2014/11/17 22:39:27]

Update description to reflect how you now store mapping.

+// View and all live ViewTarget objects. We observe the View and then delete
+// and deregister ourselves when our View is deleted.
+class ViewTarget : public ui::EventTarget,
+                   public ViewObserver {
  public:
-  ViewTarget(WindowManagerApp* app, View* view_to_wrap);
+  ViewTarget(View* view_to_wrap);

[sky, 2014/11/17 22:39:27]

explicit

   ~ViewTarget() override;
 
+  // Returns the ViewTarget for a View.
+  static ViewTarget* TargetFromView(View* view);

[sky, 2014/11/17 22:39:27]

Did you consider making the constructor private and having this create
ViewTarget if one hasn't been created yet?

[Elliot Glaysher, 2014/11/17 23:33:01]

Done. This also changes WindowManagerApp so that it no longer maintains a
mapping of view ids to ViewTargets. (And just replaces it with a set to keep
track of what Views were registered in our system, which is what we were using
it for in practice.)

+
+  // Converts |point| from |source|'s coordinates to |target|'s. If |source| is
+  // NULL, the function returns without modifying |point|. |target| cannot be
+  // NULL.
+  static void ConvertPointToTarget(const ViewTarget* source,
+                                   const ViewTarget* target,
+                                   gfx::Point* point);
+
   View* view() { return view_; }
 
+  std::vector<ViewTarget*> GetChildren() const;

[sky, 2014/11/17 22:39:27]

Should return vector of const ViewTarget (or not be const).

[Elliot Glaysher, 2014/11/17 23:33:01]

Removed const, added interface to re-add const here (and in several other places
that I had to remove to make this compile) once we remove aura from the tree.
(The EventTarget interface doesn't play well with const.)

+  ViewTarget* GetParent() const;

[sky, 2014/11/17 22:39:27]

const methods should return const pointers, otherwise you can trivially
circumvent const'ness.

+  gfx::Rect GetBounds() const;
   bool HasParent() const;
   bool IsVisible() const;
 
-  // We keep track of our children here.
-  void AddChild(ViewTarget* view);
+  const ViewTarget* GetRoot() const;
 
   // Sets a new ViewTargeter for the view, and returns the previous
   // ViewTargeter.
   scoped_ptr<ViewTargeter> SetEventTargeter(scoped_ptr<ViewTargeter> targeter);
 
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override;
   EventTarget* GetParentTarget() override;
   scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override;
   void ConvertEventToTarget(ui::EventTarget* target,
                             ui::LocatedEvent* event) override;
 
+  // Overridden from ViewObserver:
+  void OnViewDestroying(View* view) override;
+
  private:
-  // The WindowManagerApp which owns us.
-  WindowManagerApp* app_;
+  bool ConvertPointForAncestor(const ViewTarget* ancestor,
+                               gfx::Point* point) const;
+  bool ConvertPointFromAncestor(const ViewTarget* ancestor,
+                                gfx::Point* point) const;
+  bool GetTargetOffsetRelativeTo(const ViewTarget* ancestor,
+                                 gfx::Vector2d* offset) const;
 
   // The mojo::View that we dispatch to.
   View* view_;
 
-  std::vector<ViewTarget*> children_;
-
   scoped_ptr<ViewTargeter> targeter_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTarget);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_WINDOW_MANAGER_VIEW_TARGET_H_