Splits window manager like methods into ViewManagerServiceDelegate

mojo/services/view_manager/connection_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/connection_manager.h"
 
 #include "base/logging.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
@@ skipping 13 matching lines @@
 }
 
 ConnectionManager::ScopedChange::~ScopedChange() {
   connection_manager_->FinishChange();
 }
 
 ConnectionManager::ConnectionManager(
     ApplicationConnection* app_connection,
     const Callback<void()>& native_viewport_closed_callback)
     : app_connection_(app_connection),
+      wm_client_impl_(this),
       next_connection_id_(1),
-      display_manager_(app_connection,
-                       this,
-                       native_viewport_closed_callback),
+      display_manager_(app_connection, this, native_viewport_closed_callback),
       root_(new ServerView(this, RootViewId())),
       current_change_(NULL) {
   root_->SetBounds(gfx::Rect(800, 600));
 }
 
 ConnectionManager::~ConnectionManager() {
   while (!connections_created_by_connect_.empty())
     delete *(connections_created_by_connect_.begin());
   // All the connections should have been destroyed.
   DCHECK(connection_map_.empty());
@@ skipping 16 matching lines @@
   connections_created_by_connect_.erase(connection);
 
   // Notify remaining connections so that they can cleanup.
   for (ConnectionMap::const_iterator i = connection_map_.begin();
        i != connection_map_.end();
        ++i) {
     i->second->OnViewManagerServiceImplDestroyed(connection->id());
   }
 }
 
-void ConnectionManager::EmbedRoot(
+void ConnectionManager::Embed(
     const std::string& url,
     InterfaceRequest<ServiceProvider> service_provider) {
   if (connection_map_.empty()) {
+    // TODO(sky): this is unsafe and racy. Need a better way to determine the
+    // window manager.
     EmbedImpl(kInvalidConnectionId,
               String::From(url),
               RootViewId(),
               service_provider.Pass());
     return;
   }
-  ViewManagerServiceImpl* connection = GetConnection(kWindowManagerConnection);
-  connection->client()->Embed(url, service_provider.Pass());
+  wm_client_impl_.client()->Embed(url, service_provider.Pass());
 }
 
-void ConnectionManager::Embed(
+void ConnectionManager::EmbedAtView(
     ConnectionSpecificId creator_id,
     const String& url,
     Id transport_view_id,
     InterfaceRequest<ServiceProvider> service_provider) {
   EmbedImpl(creator_id,
             url,
             ViewIdFromTransportId(transport_view_id),
             service_provider.Pass())->set_delete_on_connection_error();
 }
 
@@ skipping 24 matching lines @@
     const ViewId& 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 ConnectionManager::DispatchViewInputEventToWindowManager(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(event.Pass());
+void ConnectionManager::DispatchViewInputEventToDelegate(EventPtr event) {
+  if (wm_client_impl_.client())
+    wm_client_impl_.client()->OnViewInputEvent(event.Pass());
 }
 
 void ConnectionManager::ProcessViewBoundsChanged(const ServerView* view,
                                                  const gfx::Rect& old_bounds,
                                                  const gfx::Rect& new_bounds) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end();
        ++i) {
     i->second->ProcessViewBoundsChanged(
         view, old_bounds, new_bounds, IsChangeSource(i->first));
@@ skipping 57 matching lines @@
 
 ViewManagerServiceImpl* ConnectionManager::EmbedImpl(
     const ConnectionSpecificId creator_id,
     const String& url,
     const ViewId& root_id,
     InterfaceRequest<ServiceProvider> service_provider) {
   MessagePipe pipe;
 
   ServiceProvider* view_manager_service_provider =
       app_connection_->ConnectToApplication(url)->GetServiceProvider();
+
   view_manager_service_provider->ConnectToService(
       ViewManagerServiceImpl::Client::Name_, pipe.handle1.Pass());
 
+  if (root_id == RootViewId()) {
+    MessagePipe wm_pipe;
+    view_manager_service_provider->ConnectToService(
+        WindowManagerClientImpl::Client::Name_, wm_pipe.handle1.Pass());
+    WeakBindToPipe(&wm_client_impl_, wm_pipe.handle0.Pass());
+  }
+
   std::string creator_url;
   ConnectionMap::const_iterator it = connection_map_.find(creator_id);
   if (it != connection_map_.end())
     creator_url = it->second->url();
 
   ViewManagerServiceImpl* connection =
       new ViewManagerServiceImpl(this,
                                  creator_id,
                                  creator_url,
                                  url.To<std::string>(),
@@ skipping 58 matching lines @@
 void ConnectionManager::OnWillChangeViewVisibility(const ServerView* view) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end();
        ++i) {
     i->second->ProcessWillChangeViewVisibility(view, IsChangeSource(i->first));
   }
 }
 
 }  // namespace service
 }  // namespace mojo