Get event targetting working for mouse events.

mojo/services/window_manager/window_manager_app.cc

 // 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.
 
 #include "mojo/services/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
@@ skipping 67 matching lines @@
       wrapped_view_manager_delegate_(view_manager_delegate),
       window_manager_delegate_(window_manager_delegate),
       view_manager_(nullptr),
       root_(nullptr) {
 }
 
 WindowManagerApp::~WindowManagerApp() {
   STLDeleteElements(&connections_);
 }
 
-// static
-View* WindowManagerApp::GetViewForViewTarget(ViewTarget* target) {
-  return target->view();
-}
-
-ViewTarget* WindowManagerApp::GetViewTargetForViewId(Id view) {
-  ViewIdToViewTargetMap::const_iterator it =
-      view_id_to_view_target_map_.find(view);
-  return it != view_id_to_view_target_map_.end() ? it->second : nullptr;
-}
-
 void WindowManagerApp::AddConnection(WindowManagerImpl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
   connections_.insert(connection);
 }
 
 void WindowManagerApp::RemoveConnection(WindowManagerImpl* connection) {
   DCHECK(connections_.find(connection) != connections_.end());
   connections_.erase(connection);
 }
 
@@ skipping 60 matching lines @@
 void WindowManagerApp::OnEmbed(ViewManager* view_manager,
                                View* root,
                                ServiceProviderImpl* exported_services,
                                scoped_ptr<ServiceProvider> imported_services) {
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
   root_ = root;
 
   view_event_dispatcher_.reset(new ViewEventDispatcher());
 
-  RegisterSubtree(root_, nullptr);
+  RegisterSubtree(root_);
 
   // TODO(erg): Also move the capture client over.
   //
   // capture_client_.reset(
   //     new wm::ScopedCaptureClient(window_tree_host_->window()));
 
   if (wrapped_view_manager_delegate_) {
     wrapped_view_manager_delegate_->OnEmbed(
         view_manager, root, exported_services, imported_services.Pass());
   }
@@ skipping 17 matching lines @@
 
 void WindowManagerApp::OnTreeChanged(
     const ViewObserver::TreeChangeParams& params) {
   if (params.receiver != root_)
     return;
   DCHECK(params.old_parent || params.new_parent);
   if (!params.target)
     return;
 
   if (params.new_parent) {
-    if (view_id_to_view_target_map_.find(params.target->id()) ==
-        view_id_to_view_target_map_.end()) {
-      ViewIdToViewTargetMap::const_iterator it =
-          view_id_to_view_target_map_.find(params.new_parent->id());
-      DCHECK(it != view_id_to_view_target_map_.end());
-      RegisterSubtree(params.target, it->second);
+    if (registered_view_id_set_.find(params.target->id()) ==
+        registered_view_id_set_.end()) {
+      RegisteredViewIdSet::const_iterator it =
+          registered_view_id_set_.find(params.new_parent->id());
+      DCHECK(it != registered_view_id_set_.end());
+      RegisterSubtree(params.target);
     }
   } else if (params.old_parent) {
     UnregisterSubtree(params.target);
   }
 }
 
 void WindowManagerApp::OnViewDestroying(View* view) {
   if (view != root_) {
     Unregister(view);
     return;
   }
   root_ = nullptr;
   if (focus_controller_)
     focus_controller_->RemoveObserver(this);
 }
 
-void WindowManagerApp::OnViewBoundsChanged(View* view,
-                                           const Rect& old_bounds,
-                                           const Rect& new_bounds) {
-  // aura::Window* window = GetWindowForViewId(view->id());
-  // window->SetBounds(new_bounds.To<gfx::Rect>());
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ui::EventHandler implementation:
 
 void WindowManagerApp::OnEvent(ui::Event* event) {
   if (!window_manager_client_)
     return;
 
-  View* view = GetViewForViewTarget(static_cast<ViewTarget*>(event->target()));
+  View* view = static_cast<ViewTarget*>(event->target())->view();
   if (!view)
     return;
 
   if (focus_controller_)
     focus_controller_->OnEvent(event);
 
   window_manager_client_->DispatchInputEventToView(view->id(),
                                                    Event::From(*event));
 }
 
@@ skipping 16 matching lines @@
     (*it)->NotifyWindowActivated(GetIdForView(gained_active),
                                  GetIdForView(lost_active));
   }
   if (gained_active)
     gained_active->MoveToFront();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, private:
 
-void WindowManagerApp::RegisterSubtree(View* view, ViewTarget* parent) {
+void WindowManagerApp::RegisterSubtree(View* view) {
   view->AddObserver(this);
-  DCHECK(view_id_to_view_target_map_.find(view->id()) ==
-         view_id_to_view_target_map_.end());
-  ViewTarget* target = new ViewTarget(this, view);
+  DCHECK(registered_view_id_set_.find(view->id()) ==
+         registered_view_id_set_.end());
   // All events pass through the root during dispatch, so we only need a handler
   // installed there.
   if (view == root_) {
+    ViewTarget* target = ViewTarget::TargetFromView(view);
     target->SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter()));
     target->AddPreTargetHandler(this);
     view_event_dispatcher_->SetRootViewTarget(target);
   }
-  // TODO(erg): Why is there no matching RemoveChild()? How does that work in
-  // the aura version?
-  view_id_to_view_target_map_[view->id()] = target;
+  registered_view_id_set_.insert(view->id());
   View::Children::const_iterator it = view->children().begin();
   for (; it != view->children().end(); ++it)
-    RegisterSubtree(*it, target);
+    RegisterSubtree(*it);
 }
 
 void WindowManagerApp::UnregisterSubtree(View* view) {
   for (View* child : view->children())
     UnregisterSubtree(child);
   Unregister(view);
 }
 
 void WindowManagerApp::Unregister(View* view) {
-  ViewIdToViewTargetMap::iterator it =
-      view_id_to_view_target_map_.find(view->id());
-  if (it == view_id_to_view_target_map_.end()) {
+  RegisteredViewIdSet::iterator it = registered_view_id_set_.find(view->id());
+  if (it == registered_view_id_set_.end()) {
     // Because we unregister in OnViewDestroying() we can still get a subsequent
     // OnTreeChanged for the same view. Ignore this one.
     return;
   }
   view->RemoveObserver(this);
-  DCHECK(it != view_id_to_view_target_map_.end());
-  // Delete before we remove from map as destruction may want to look up view
-  // for window.
-  delete it->second;
-  view_id_to_view_target_map_.erase(it);
+  DCHECK(it != registered_view_id_set_.end());
+  registered_view_id_set_.erase(it);
 }
 
 void WindowManagerApp::DispatchInputEventToView(View* view, EventPtr event) {
   window_manager_client_->DispatchInputEventToView(view->id(), event.Pass());
 }
 
 void WindowManagerApp::SetViewportSize(const gfx::Size& size) {
   window_manager_client_->SetViewportSize(Size::From(size));
 }
 
@@ skipping 18 matching lines @@
   view_manager_app->ConnectToService(&window_manager_client_);
 }
 
 void WindowManagerApp::Create(ApplicationConnection* connection,
                               InterfaceRequest<WindowManagerInternal> request) {
   WindowManagerInternalImpl* impl = new WindowManagerInternalImpl(this);
   BindToRequest(impl, &request);
 }
 
 }  // namespace mojo