Refactors event dispatching of NativeViewport into its own interface

mojo/services/view_manager/view_manager_unittest.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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 233 matching lines @@
     return result;
   }
 
   void set_view_manager(ViewManagerService* view_manager) {
     view_manager_ = view_manager;
     SetInstance(this);
   }
 
  private:
   friend class TestViewManagerClientConnection;
-  friend class WindowManagerInternalServiceImpl;
+  friend class TestWindowManagerImpl;
 
   void set_router(mojo::internal::Router* router) { router_ = router; }
 
   void set_window_manager_client(WindowManagerInternalClient* client) {
     window_manager_client_ = client;
   }
 
   static void RunMainLoop() {
     DCHECK(!main_run_loop_);
     main_run_loop_ = new base::RunLoop;
@@ skipping 135 matching lines @@
     tracker_.OnViewPropertyChanged(view, name, new_data.Pass());
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
 };
 
-class WindowManagerInternalServiceImpl
-    : public InterfaceImpl<WindowManagerInternalService> {
- public:
-  explicit WindowManagerInternalServiceImpl(
-      TestViewManagerClientConnection* connection)
-      : connection_(connection) {}
-  ~WindowManagerInternalServiceImpl() override {}
-
-  // InterfaceImpl:
-  void OnConnectionEstablished() override {
-    connection_->proxy()->set_window_manager_client(client());
-  }
-
-  void OnViewInputEvent(mojo::EventPtr event) override {}
-
- private:
-  TestViewManagerClientConnection* connection_;
-
-  DISALLOW_COPY_AND_ASSIGN(WindowManagerInternalServiceImpl);
-};
-
 // Used with ViewManagerService::Embed(). Creates a
 // TestViewManagerClientConnection, which creates and owns the ViewManagerProxy.
-class EmbedApplicationLoader
-    : public ApplicationLoader,
-      ApplicationDelegate,
-      public InterfaceFactory<ViewManagerClient>,
-      public InterfaceFactory<WindowManagerInternalService> {
+class EmbedApplicationLoader : public ApplicationLoader,
+                               ApplicationDelegate,
+                               public InterfaceFactory<ViewManagerClient> {
  public:
-  EmbedApplicationLoader() : last_view_manager_client_(nullptr) {}
+  EmbedApplicationLoader() {}
   ~EmbedApplicationLoader() override {}
 
   // ApplicationLoader implementation:
   void Load(ApplicationManager* manager,
             const GURL& url,
             scoped_refptr<LoadCallbacks> callbacks) override {
     ScopedMessagePipeHandle shell_handle = callbacks->RegisterApplication();
     if (!shell_handle.is_valid())
       return;
     scoped_ptr<ApplicationImpl> app(new ApplicationImpl(this,
                                                         shell_handle.Pass()));
     apps_.push_back(app.release());
   }
   void OnApplicationError(ApplicationManager* manager,
                           const GURL& url) override {}
 
   // ApplicationDelegate implementation:
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService<ViewManagerClient>(this);
-    connection->AddService<WindowManagerInternalService>(this);
     return true;
   }
 
   // InterfaceFactory<ViewManagerClient> implementation:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<ViewManagerClient> request) override {
-    last_view_manager_client_ = new TestViewManagerClientConnection();
-    BindToRequest(last_view_manager_client_, &request);
-  }
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<WindowManagerInternalService> request) override {
-    BindToRequest(
-        new WindowManagerInternalServiceImpl(last_view_manager_client_),
-        &request);
+    BindToRequest(new TestViewManagerClientConnection(), &request);
   }
 
  private:
-  // Used so that TestViewManagerClientConnection and
-  // WindowManagerInternalServiceImpl can share the same TestChangeTracker.
-  TestViewManagerClientConnection* last_view_manager_client_;
   ScopedVector<ApplicationImpl> apps_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedApplicationLoader);
 };
 
-class TestWindowManagerImpl
-    : public InterfaceImpl<WindowManager>,
-      public InterfaceFactory<WindowManagerInternalService> {
+class TestWindowManagerImpl : public InterfaceImpl<WindowManager> {
  public:
   explicit TestWindowManagerImpl(ApplicationConnection* connection)
       : view_manager_client_(nullptr), got_initial_embed_(false) {
     // WindowManager is expected to establish initial connection to VM.
     ApplicationConnection* view_manager_app =
         connection->ConnectToApplication("mojo:view_manager");
-    view_manager_app->AddService<WindowManagerInternalService>(this);
     view_manager_app->ConnectToService(&view_manager_);
+    view_manager_app->ConnectToService(&window_manager_client_);
 
     view_manager_client_ = new TestViewManagerClientConnection();
     view_manager_.set_client(view_manager_client_);
+    view_manager_client_->proxy()->set_window_manager_client(
+        window_manager_client_.get());
     view_manager_client_->proxy()->set_view_manager(view_manager_.get());
   }
 
   virtual ~TestWindowManagerImpl() {}
 
   TestViewManagerClientConnection* view_manager_client() {
     return view_manager_client_;
   }
 
   // InterfaceImpl:
   virtual void OnConnectionEstablished() override {}
 
   // WindowManager:
   virtual void Embed(
       const String& url,
       InterfaceRequest<ServiceProvider> service_provider) override {
     if (!got_initial_embed_) {
       got_initial_embed_ = true;
       return;
     }
     view_manager_client_->tracker()->DelegateEmbed(url);
   }
 
-  // InterfaceFactory<>:
-  virtual void Create(
-      ApplicationConnection* connection,
-      InterfaceRequest<WindowManagerInternalService> request) override {
-    BindToRequest(new WindowManagerInternalServiceImpl(view_manager_client_),
-                  &request);
-  }
-
  private:
   ViewManagerServicePtr view_manager_;
   TestViewManagerClientConnection* view_manager_client_;
+  WindowManagerInternalClientPtr window_manager_client_;
 
   // Did we get Embed() yet?
   bool got_initial_embed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowManagerImpl);
 };
 
 class WindowManagerLoader : public ApplicationLoader,
                             public ApplicationDelegate,
                             public InterfaceFactory<WindowManager> {
@@ skipping 1092 matching lines @@
 
 // TODO(sky): add coverage of test that destroys connections and ensures other
 // connections get deletion notification.
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdViews/AddView and the like don't result in messages to the
 // originating connection.
 
 }  // namespace service
 }  // namespace mojo