Splits window manager like methods into ViewManagerServiceDelegate

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/aura/aura_init.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
@@ skipping 63 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, public:
 
 WindowManagerApp::WindowManagerApp(
     ViewManagerDelegate* view_manager_delegate,
     WindowManagerDelegate* window_manager_delegate)
     : shell_(nullptr),
+      window_manager_service2_factory_(this),
       window_manager_service_factory_(this),
       wrapped_view_manager_delegate_(view_manager_delegate),
-      wrapped_window_manager_delegate_(window_manager_delegate),
+      window_manager_delegate_(window_manager_delegate),
       view_manager_(NULL),
       root_(NULL),
-      dummy_delegate_(new DummyDelegate) {
+      dummy_delegate_(new DummyDelegate),
+      window_manager_client_(nullptr) {
 }
 
 WindowManagerApp::~WindowManagerApp() {}
 
 // static
 View* WindowManagerApp::GetViewForWindow(aura::Window* window) {
   return window->GetProperty(kViewKey);
 }
 
 aura::Window* WindowManagerApp::GetWindowForViewId(Id view) {
   ViewIdToWindowMap::const_iterator it = view_id_to_window_map_.find(view);
   return it != view_id_to_window_map_.end() ? it->second : NULL;
 }
 
-void WindowManagerApp::AddConnection(WindowManagerServiceImpl* connection) {
+void WindowManagerApp::AddConnection(WindowManagerService2Impl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
   connections_.insert(connection);
 }
 
-void WindowManagerApp::RemoveConnection(WindowManagerServiceImpl* connection) {
+void WindowManagerApp::RemoveConnection(WindowManagerService2Impl* connection) {
   DCHECK(connections_.find(connection) != connections_.end());
   connections_.erase(connection);
 }
 
 void WindowManagerApp::SetCapture(Id view) {
   capture_client_->capture_client()->SetCapture(GetWindowForViewId(view));
   // TODO(beng): notify connected clients that capture has changed, probably
   //             by implementing some capture-client observer.
 }
 
@@ skipping 30 matching lines @@
 
 void WindowManagerApp::Initialize(ApplicationImpl* impl) {
   shell_ = impl->shell();
   aura_init_.reset(new AuraInit);
   view_manager_client_factory_.reset(
       new ViewManagerClientFactory(shell_, this));
 }
 
 bool WindowManagerApp::ConfigureIncomingConnection(
     ApplicationConnection* connection) {
+  connection->AddService(&window_manager_service2_factory_);
+  connection->AddService(view_manager_client_factory_.get());
   connection->AddService(&window_manager_service_factory_);
-  connection->AddService(view_manager_client_factory_.get());
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewManagerDelegate implementation:
 
 void WindowManagerApp::OnEmbed(ViewManager* view_manager,
                                View* root,
                                ServiceProviderImpl* exported_services,
                                scoped_ptr<ServiceProvider> imported_services) {
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
-  view_manager_->SetWindowManagerDelegate(this);
   root_ = root;
 
   window_tree_host_.reset(new WindowTreeHostMojo(shell_, root_));
   window_tree_host_->window()->SetBounds(root->bounds());
   window_tree_host_->window()->Show();
 
   RegisterSubtree(root_, window_tree_host_->window());
 
   capture_client_.reset(
       new wm::ScopedCaptureClient(window_tree_host_->window()));
@@ skipping 12 matching lines @@
 void WindowManagerApp::OnViewManagerDisconnected(
     ViewManager* view_manager) {
   DCHECK_EQ(view_manager_, view_manager);
   if (wrapped_view_manager_delegate_)
     wrapped_view_manager_delegate_->OnViewManagerDisconnected(view_manager);
   view_manager_ = NULL;
   base::MessageLoop::current()->Quit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WindowManagerApp, WindowManagerDelegate implementation:
-
-void WindowManagerApp::Embed(
-    const String& url,
-    InterfaceRequest<ServiceProvider> service_provider) {
-  if (wrapped_window_manager_delegate_)
-    wrapped_window_manager_delegate_->Embed(url, service_provider.Pass());
-}
-
-void WindowManagerApp::DispatchEvent(EventPtr event) {
-  scoped_ptr<ui::Event> ui_event = event.To<scoped_ptr<ui::Event> >();
-  if (ui_event)
-    window_tree_host_->SendEventToProcessor(ui_event.get());
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewObserver implementation:
 
 void WindowManagerApp::OnTreeChanged(
     const ViewObserver::TreeChangeParams& params) {
   if (params.receiver != root_)
     return;
   DCHECK(params.old_parent || params.new_parent);
   if (!params.target)
     return;
 
@@ skipping 30 matching lines @@
                                            const gfx::Rect& old_bounds,
                                            const gfx::Rect& new_bounds) {
   aura::Window* window = GetWindowForViewId(view->id());
   window->SetBounds(new_bounds);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ui::EventHandler implementation:
 
 void WindowManagerApp::OnEvent(ui::Event* event) {
-  aura::Window* window = static_cast<aura::Window*>(event->target());
-  view_manager_->DispatchEvent(GetViewForWindow(window), Event::From(*event));
+  if (!window_manager_client_)
+    return;
+
+  View* view = GetViewForWindow(static_cast<aura::Window*>(event->target()));
+  if (!view)
+    return;
+
+  window_manager_client_->DispatchInputEventToView(view->id(),
+                                                   Event::From(*event));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, aura::client::FocusChangeObserver implementation:
 
 void WindowManagerApp::OnWindowFocused(aura::Window* gained_focus,
                                        aura::Window* lost_focus) {
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyViewFocused(GetIdForWindow(gained_focus),
@@ skipping 55 matching lines @@
   }
   view->RemoveObserver(this);
   DCHECK(it != view_id_to_window_map_.end());
   // Delete before we remove from map as destruction may want to look up view
   // for window.
   delete it->second;
   view_id_to_window_map_.erase(it);
 }
 
 }  // namespace mojo