Splits window manager like methods into ViewManagerServiceDelegate

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"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/application/interface_factory_impl.h"
 #include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/services/public/cpp/view_manager/types.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 #include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
+#include "mojo/services/public/interfaces/window_manager/window_manager.mojom.h"
 #include "mojo/services/view_manager/ids.h"
 #include "mojo/services/view_manager/test_change_tracker.h"
 #include "mojo/shell/shell_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/win/window_impl.h"
 #endif
 
 namespace mojo {
 namespace service {
 
 namespace {
 
 const char kTestServiceURL[] = "mojo:test_url";
 const char kTestServiceURL2[] = "mojo:test_url2";
 
 // ViewManagerProxy is a proxy to an ViewManagerService. It handles invoking
 // ViewManagerService functions on the right thread in a synchronous manner
 // (each ViewManagerService cover function blocks until the response from the
 // ViewManagerService is returned). In addition it tracks the set of
 // ViewManagerClient messages received by way of a vector of Changes. Use
 // DoRunLoopUntilChangesCount() to wait for a certain number of messages to be
 // received.
 class ViewManagerProxy : public TestChangeTracker::Delegate {
  public:
   explicit ViewManagerProxy(TestChangeTracker* tracker)
       : tracker_(tracker),
-        main_loop_(NULL),
-        view_manager_(NULL),
+        main_loop_(nullptr),
+        view_manager_(nullptr),
+        window_manager_client_(nullptr),
         quit_count_(0),
-        router_(NULL) {
+        router_(nullptr) {
     SetInstance(this);
   }
 
   virtual ~ViewManagerProxy() {
   }
 
   // Returns true if in an initial state. If this returns false it means the
   // last test didn't clean up properly, or most likely didn't invoke
   // WaitForInstance() when it needed to.
   static bool IsInInitialState() { return instance_ == NULL; }
 
   // Runs a message loop until the single instance has been created.
   static ViewManagerProxy* WaitForInstance() {
     if (!instance_)
       RunMainLoop();
     ViewManagerProxy* instance = instance_;
     instance_ = NULL;
     return instance;
   }
 
   ViewManagerService* view_manager() { return view_manager_; }
+  WindowManagerClient* window_manager_client() {
+    return window_manager_client_;
+  }
 
   // Runs the main loop until |count| changes have been received.
   std::vector<Change> DoRunLoopUntilChangesCount(size_t count) {
     DCHECK_EQ(0u, quit_count_);
     if (tracker_->changes()->size() >= count) {
       CopyChangesFromTracker();
       return changes_;
     }
     quit_count_ = count - tracker_->changes()->size();
     // Run the current message loop. When |count| Changes have been received,
@@ skipping 125 matching lines @@
         view_id,
         visible,
         base::Bind(
             &ViewManagerProxy::GotResult, base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
 
  private:
   friend class TestViewManagerClientConnection;
+  friend class WindowManagerServiceImpl;
 
   void set_router(mojo::internal::Router* router) { router_ = router; }
 
   void set_view_manager(ViewManagerService* view_manager) {
     view_manager_ = view_manager;
   }
 
+  void set_window_manager_client(WindowManagerClient* client) {
+    window_manager_client_ = client;
+  }
+
   static void RunMainLoop() {
     DCHECK(!main_run_loop_);
     main_run_loop_ = new base::RunLoop;
     main_run_loop_->Run();
     delete main_run_loop_;
     main_run_loop_ = NULL;
   }
 
   void QuitCountReached() {
     CopyChangesFromTracker();
@@ skipping 40 matching lines @@
   static ViewManagerProxy* instance_;
   static base::RunLoop* main_run_loop_;
   static bool in_embed_;
 
   TestChangeTracker* tracker_;
 
   // MessageLoop of the test.
   base::MessageLoop* main_loop_;
 
   ViewManagerService* view_manager_;
+  WindowManagerClient* window_manager_client_;
 
   // Number of changes we're waiting on until we quit the current loop.
   size_t quit_count_;
 
   std::vector<Change> changes_;
 
   mojo::internal::Router* router_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerProxy);
 };
 
 // static
 ViewManagerProxy* ViewManagerProxy::instance_ = NULL;
 
 // static
 base::RunLoop* ViewManagerProxy::main_run_loop_ = NULL;
 
 // static
 bool ViewManagerProxy::in_embed_ = false;
 
 class TestViewManagerClientConnection
     : public InterfaceImpl<ViewManagerClient> {
  public:
-  TestViewManagerClientConnection() : connection_(&tracker_) {
-    tracker_.set_delegate(&connection_);
+  TestViewManagerClientConnection() : proxy_(&tracker_) {
+    tracker_.set_delegate(&proxy_);
   }
 
+  TestChangeTracker* tracker() { return &tracker_; }
+
+  ViewManagerProxy* proxy() { return &proxy_; }
+
   // InterfaceImpl:
   virtual void OnConnectionEstablished() override {
-    connection_.set_router(internal_state()->router());
-    connection_.set_view_manager(client());
+    proxy_.set_router(internal_state()->router());
+    proxy_.set_view_manager(client());
   }
 
   // ViewManagerClient:
   virtual void OnEmbed(
       ConnectionSpecificId connection_id,
       const String& creator_url,
       ViewDataPtr root,
       InterfaceRequest<ServiceProvider> services) override {
     tracker_.OnEmbed(connection_id, creator_url, root.Pass());
   }
@@ skipping 18 matching lines @@
     tracker_.OnViewVisibilityChanged(view, visible);
   }
   virtual void OnViewDrawnStateChanged(uint32_t view, bool drawn) override {
     tracker_.OnViewDrawnStateChanged(view, drawn);
   }
   virtual void OnViewInputEvent(Id view_id,
                                 EventPtr event,
                                 const Callback<void()>& callback) override {
     tracker_.OnViewInputEvent(view_id, event.Pass());
   }
-  virtual void Embed(
-      const String& url,
-      InterfaceRequest<ServiceProvider> service_provider) override {
-    tracker_.DelegateEmbed(url);
-  }
-  virtual void DispatchOnViewInputEvent(mojo::EventPtr event) override {
-  }
 
  private:
   TestChangeTracker tracker_;
-  ViewManagerProxy connection_;
+  ViewManagerProxy proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
 };
 
+class WindowManagerServiceImpl : public InterfaceImpl<WindowManagerService> {
+ public:
+  explicit WindowManagerServiceImpl(TestViewManagerClientConnection* connection)
+      : connection_(connection) {}
+  virtual ~WindowManagerServiceImpl() {}
+
+  // InterfaceImpl:
+  virtual void OnConnectionEstablished() override {
+    connection_->proxy()->set_window_manager_client(client());
+  }
+
+  // WindowManagerService:
+  virtual void Embed(
+      const String& url,
+      InterfaceRequest<ServiceProvider> service_provider) override {
+    connection_->tracker()->DelegateEmbed(url);
+  }
+  virtual void OnViewInputEvent(mojo::EventPtr event) override {}
+
+ private:
+  TestViewManagerClientConnection* connection_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowManagerServiceImpl);
+};
+
 // Used with ViewManagerService::Embed(). Creates a
 // TestViewManagerClientConnection, which creates and owns the ViewManagerProxy.
 class EmbedApplicationLoader : public ApplicationLoader,
                                ApplicationDelegate,
-                               public InterfaceFactory<ViewManagerClient> {
+                               public InterfaceFactory<ViewManagerClient>,
+                               public InterfaceFactory<WindowManagerService> {
  public:
-  EmbedApplicationLoader() {}
+  EmbedApplicationLoader() : last_view_manager_client_(nullptr) {}
   virtual ~EmbedApplicationLoader() {}
 
   // ApplicationLoader implementation:
   virtual 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());
   }
   virtual void OnApplicationError(ApplicationManager* manager,
                                   const GURL& url) override {}
 
   // ApplicationDelegate implementation:
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       override {
-    connection->AddService(this);
+    connection->AddService<ViewManagerClient>(this);
+    connection->AddService<WindowManagerService>(this);
     return true;
   }
 
   // InterfaceFactory<ViewManagerClient> implementation:
   virtual void Create(ApplicationConnection* connection,
                       InterfaceRequest<ViewManagerClient> request) override {
-    BindToRequest(new TestViewManagerClientConnection, &request);
+    last_view_manager_client_ = new TestViewManagerClientConnection;
+    BindToRequest(last_view_manager_client_, &request);
+  }
+  virtual void Create(ApplicationConnection* connection,
+                      InterfaceRequest<WindowManagerService> request) override {
+    BindToRequest(new WindowManagerServiceImpl(last_view_manager_client_),
+                  &request);
   }
 
  private:
+  // Used so that TestViewManagerClientConnection and
+  // WindowManagerServiceImpl can share the same TestChangeTracker.
+  TestViewManagerClientConnection* last_view_manager_client_;
   ScopedVector<ApplicationImpl> apps_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedApplicationLoader);
 };
 
 // Creates an id used for transport from the specified parameters.
 Id BuildViewId(ConnectionSpecificId connection_id,
                ConnectionSpecificId view_id) {
   return (connection_id << 16) | view_id;
 }
@@ skipping 758 matching lines @@
 }
 
 TEST_F(ViewManagerTest, OnViewInput) {
   ASSERT_TRUE(connection_->CreateView(BuildViewId(1, 1)));
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Dispatch an event to the view and verify its received.
   {
     EventPtr event(Event::New());
     event->action = static_cast<EventType>(1);
-    connection_->view_manager()->DispatchOnViewInputEvent(BuildViewId(1, 1),
-                                                          event.Pass());
+    connection_->window_manager_client()->DispatchInputEventToView(
+        BuildViewId(1, 1), event.Pass());
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("InputEvent view=1,1 event_action=1", changes[0]);
   }
 }
 
 TEST_F(ViewManagerTest, EmbedWithSameViewId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
@@ skipping 220 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