Move focus from the view manager to the window manager.

mojo/services/view_manager/root_node_manager.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/view_manager/root_node_manager.h"
 
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/view_manager/view_manager_service_impl.h"
-#include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 
 namespace mojo {
 namespace service {
 
 RootNodeManager::ScopedChange::ScopedChange(
     ViewManagerServiceImpl* connection,
     RootNodeManager* root,
     bool is_delete_node)
     : root_(root),
@@ skipping 23 matching lines @@
       next_connection_id_(1),
       root_view_manager_(app_connection,
                          this,
                          view_manager_delegate,
                          native_viewport_closed_callback),
       root_(new Node(this, RootNodeId())),
       current_change_(NULL) {
 }
 
 RootNodeManager::~RootNodeManager() {
-  aura::client::FocusClient* focus_client =
-      aura::client::GetFocusClient(root_->window());
-  focus_client->RemoveObserver(this);
   while (!connections_created_by_connect_.empty())
     delete *(connections_created_by_connect_.begin());
   // All the connections should have been destroyed.
   DCHECK(connection_map_.empty());
   root_.reset();
 }
 
 ConnectionSpecificId RootNodeManager::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
@@ skipping 76 matching lines @@
 const ViewManagerServiceImpl* RootNodeManager::GetConnectionWithRoot(
     const NodeId& id) const {
   for (ConnectionMap::const_iterator i = connection_map_.begin();
        i != connection_map_.end(); ++i) {
     if (i->second->HasRoot(id))
       return i->second;
   }
   return NULL;
 }
 
-void RootNodeManager::DispatchNodeInputEventToWindowManager(
-    const Node* node,
-    const ui::Event* event) {
+void RootNodeManager::DispatchNodeInputEventToWindowManager(EventPtr event) {
   // Input events are forwarded to the WindowManager. The WindowManager
   // eventually calls back to us with DispatchOnViewInputEvent().
   ViewManagerServiceImpl* connection = GetConnection(kWindowManagerConnection);
   if (!connection)
     return;
-  connection->client()->DispatchOnViewInputEvent(
-      NodeIdToTransportId(node->id()),
-      TypeConverter<EventPtr, ui::Event>::ConvertFrom(*event));
+  connection->client()->DispatchOnViewInputEvent(event.Pass());
 }
 
 void RootNodeManager::ProcessNodeBoundsChanged(const Node* node,
                                                const gfx::Rect& old_bounds,
                                                const gfx::Rect& new_bounds) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end(); ++i) {
     i->second->ProcessNodeBoundsChanged(node, old_bounds, new_bounds,
                                         IsChangeSource(i->first));
   }
@@ skipping 19 matching lines @@
   }
 }
 
 void RootNodeManager::ProcessNodeDeleted(const NodeId& node) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end(); ++i) {
     i->second->ProcessNodeDeleted(node, IsChangeSource(i->first));
   }
 }
 
-void RootNodeManager::OnWindowFocused(aura::Window* gained_focus,
-                                      aura::Window* lost_focus) {
-  Node* focused_node = gained_focus ? Node::NodeForWindow(gained_focus) : NULL;
-  Node* blurred_node = lost_focus ? Node::NodeForWindow(lost_focus) : NULL;
-  for (ConnectionMap::iterator i = connection_map_.begin();
-       i != connection_map_.end(); ++i) {
-    i->second->ProcessFocusChanged(focused_node, blurred_node,
-                                   IsChangeSource(i->first));
-  }
-}
-
 void RootNodeManager::PrepareForChange(ScopedChange* change) {
   // Should only ever have one change in flight.
   CHECK(!current_change_);
   current_change_ = change;
 }
 
 void RootNodeManager::FinishChange() {
   // PrepareForChange/FinishChange should be balanced.
   CHECK(current_change_);
   current_change_ = NULL;
@@ skipping 40 matching lines @@
   if (!root_view_manager_.in_setup())
     ProcessNodeHierarchyChanged(node, new_parent, old_parent);
 }
 
 void RootNodeManager::OnNodeBoundsChanged(const Node* node,
                                           const gfx::Rect& old_bounds,
                                           const gfx::Rect& new_bounds) {
   ProcessNodeBoundsChanged(node, old_bounds, new_bounds);
 }
 
-void RootNodeManager::OnNodeInputEvent(const Node* node,
-                                       const ui::Event* event) {
-  DispatchNodeInputEventToWindowManager(node, event);
-}
-
 }  // namespace service
 }  // namespace mojo