Refactors event dispatching of NativeViewport into its own interface

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 "base/stl_util.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"
 #include "mojo/services/view_manager/connection_manager_delegate.h"
 #include "mojo/services/view_manager/view_manager_service_impl.h"
 
 namespace mojo {
 namespace service {
 
+class WindowManagerInternalClientImpl
+    : public InterfaceImpl<WindowManagerInternalClient> {
+ public:
+  WindowManagerInternalClientImpl(WindowManagerInternalClient* real_client,
+                                  ErrorHandler* error_handler)
+      : real_client_(real_client), error_handler_(error_handler) {}
+  ~WindowManagerInternalClientImpl() override {}
+
+  // WindowManagerInternalClient:
+  void DispatchInputEventToView(Id transport_view_id, EventPtr event) override {
+    real_client_->DispatchInputEventToView(transport_view_id, event.Pass());
+  }
+
+  // InterfaceImpl:
+  void OnConnectionError() override { error_handler_->OnConnectionError(); }
+
+ private:
+  WindowManagerInternalClient* real_client_;
+  ErrorHandler* error_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowManagerInternalClientImpl);
+};
+
 ConnectionManager::ScopedChange::ScopedChange(
     ViewManagerServiceImpl* connection,
     ConnectionManager* connection_manager,
     bool is_delete_view)
     : connection_manager_(connection_manager),
       connection_id_(connection->id()),
       is_delete_view_(is_delete_view) {
   connection_manager_->PrepareForChange(this);
 }
 
 ConnectionManager::ScopedChange::~ScopedChange() {
   connection_manager_->FinishChange();
 }
 
 ConnectionManager::ConnectionManager(ApplicationConnection* app_connection,
                                      ConnectionManagerDelegate* delegate)
     : app_connection_(app_connection),
       delegate_(delegate),
       window_manager_vm_service_(nullptr),
       next_connection_id_(1),
       display_manager_(
           app_connection,
           this,
           base::Bind(&ConnectionManagerDelegate::OnNativeViewportDestroyed,
                      base::Unretained(delegate))),
       root_(new ServerView(this, RootViewId())),
       current_change_(NULL),
       in_destructor_(false) {
-  app_connection->ConnectToService(&window_manager_);
-  window_manager_.set_client(this);
-  window_manager_.set_error_handler(this);
   // |app_connection| originates from the WindowManager. Let it connect
-  // directly to the ViewManager.
-  app_connection->AddService(this);
+  // directly to the ViewManager and WindowManagerInternalClient.
+  app_connection->AddService(
+      static_cast<InterfaceFactory<ViewManagerService>*>(this));
+  app_connection->AddService(
+      static_cast<InterfaceFactory<WindowManagerInternalClient>*>(this));
   root_->SetBounds(gfx::Rect(800, 600));
 }
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
   STLDeleteValues(&connection_map_);
   // All the connections should have been destroyed.
   DCHECK(connection_map_.empty());
   root_.reset();
@@ skipping 80 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::DispatchViewInputEventToDelegate(EventPtr event) {
-  window_manager_->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 163 matching lines @@
       new ViewManagerServiceImpl(this,
                                  kInvalidConnectionId,
                                  std::string(),
                                  std::string("mojo:window_manager"),
                                  RootViewId(),
                                  InterfaceRequest<ServiceProvider>());
   AddConnection(window_manager_vm_service_);
   WeakBindToRequest(window_manager_vm_service_, &request);
 }
 
+void ConnectionManager::Create(
+    ApplicationConnection* connection,
+    InterfaceRequest<WindowManagerInternalClient> request) {
+  if (wm_internal_client_impl_.get()) {
+    VLOG(1) << "WindowManagerInternalClient requested more than once.";
+    return;
+  }
+
+  wm_internal_client_impl_.reset(
+      new WindowManagerInternalClientImpl(this, this));
+  WeakBindToRequest(wm_internal_client_impl_.get(), &request);
+}
+
 void ConnectionManager::OnConnectionError() {
   delegate_->OnLostConnectionToWindowManager();
 }
 
 }  // namespace service
 }  // namespace mojo