More user id tracking for mus:

components/mus/ws/window_tree_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 <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
-#include "cc/output/copy_output_request.h"
 #include "components/mus/common/types.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/client_connection.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/connection_manager_delegate.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/display_manager_factory.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_surface_manager_test_api.h"
 #include "components/mus/ws/test_change_tracker.h"
+#include "components/mus/ws/test_utils.h"
 #include "components/mus/ws/window_tree_host_connection.h"
 #include "components/mus/ws/window_tree_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/services/network/public/interfaces/url_loader.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
-using mojo::Array;
-using mojo::InterfaceRequest;
-using mojo::String;
-using mus::mojom::Event;
-using mus::mojom::EventPtr;
-using mus::mojom::LocationData;
-using mus::mojom::PointerData;
-using mus::mojom::WindowDataPtr;
-
 namespace mus {
 namespace ws {
+namespace test {
 namespace {
 
 std::string WindowIdToString(const WindowId& id) {
   return base::StringPrintf("%d,%d", id.connection_id, id.window_id);
 }
 
 ClientWindowId BuildClientWindowId(WindowTreeImpl* tree,
                                    ConnectionSpecificId window_id) {
   return ClientWindowId(WindowIdToTransportId(WindowId(tree->id(), window_id)));
 }
@@ skipping 38 matching lines @@
   void OnAccelerator(uint32_t id, mojom::EventPtr event) override {}
 
   bool got_create_top_level_window_;
   uint32_t change_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowManager);
 };
 
 // -----------------------------------------------------------------------------
 
-// WindowTreeClient implementation that logs all calls to a TestChangeTracker.
-// TODO(sky): refactor so both this and WindowTreeAppTest share code.
-class TestWindowTreeClient : public mus::mojom::WindowTreeClient {
- public:
-  TestWindowTreeClient() : binding_(this), record_on_change_completed_(false) {}
-  ~TestWindowTreeClient() override {}
-
-  TestChangeTracker* tracker() { return &tracker_; }
-
-  void Bind(mojo::InterfaceRequest<mojom::WindowTreeClient> request) {
-    binding_.Bind(std::move(request));
-  }
-
-  void set_record_on_change_completed(bool value) {
-    record_on_change_completed_ = value;
-  }
-
- private:
-  // WindowTreeClient:
-  void OnEmbed(uint16_t connection_id,
-               WindowDataPtr root,
-               mus::mojom::WindowTreePtr tree,
-               Id focused_window_id,
-               uint32_t access_policy) override {
-    // TODO(sky): add test coverage of |focused_window_id|.
-    tracker_.OnEmbed(connection_id, std::move(root));
-  }
-  void OnEmbeddedAppDisconnected(uint32_t window) override {
-    tracker_.OnEmbeddedAppDisconnected(window);
-  }
-  void OnUnembed(Id window_id) override { tracker_.OnUnembed(window_id); }
-  void OnLostCapture(Id window_id) override {}
-  void OnTopLevelCreated(uint32_t change_id,
-                         mojom::WindowDataPtr data) override {
-    tracker_.OnTopLevelCreated(change_id, std::move(data));
-  }
-  void OnWindowBoundsChanged(uint32_t window,
-                             mojo::RectPtr old_bounds,
-                             mojo::RectPtr new_bounds) override {
-    tracker_.OnWindowBoundsChanged(window, std::move(old_bounds),
-                                   std::move(new_bounds));
-  }
-  void OnClientAreaChanged(
-      uint32_t window_id,
-      mojo::InsetsPtr new_client_area,
-      mojo::Array<mojo::RectPtr> new_additional_client_areas) override {}
-  void OnTransientWindowAdded(uint32_t window_id,
-                              uint32_t transient_window_id) override {}
-  void OnTransientWindowRemoved(uint32_t window_id,
-                                uint32_t transient_window_id) override {}
-  void OnWindowViewportMetricsChanged(
-      mojo::Array<uint32_t> window_ids,
-      mojom::ViewportMetricsPtr old_metrics,
-      mojom::ViewportMetricsPtr new_metrics) override {
-    tracker_.OnWindowViewportMetricsChanged(std::move(old_metrics),
-                                            std::move(new_metrics));
-  }
-  void OnWindowHierarchyChanged(uint32_t window,
-                                uint32_t new_parent,
-                                uint32_t old_parent,
-                                Array<WindowDataPtr> windows) override {
-    tracker_.OnWindowHierarchyChanged(window, new_parent, old_parent,
-                                      std::move(windows));
-  }
-  void OnWindowReordered(uint32_t window_id,
-                         uint32_t relative_window_id,
-                         mojom::OrderDirection direction) override {
-    tracker_.OnWindowReordered(window_id, relative_window_id, direction);
-  }
-  void OnWindowDeleted(uint32_t window) override {
-    tracker_.OnWindowDeleted(window);
-  }
-  void OnWindowVisibilityChanged(uint32_t window, bool visible) override {
-    tracker_.OnWindowVisibilityChanged(window, visible);
-  }
-  void OnWindowDrawnStateChanged(uint32_t window, bool drawn) override {
-    tracker_.OnWindowDrawnStateChanged(window, drawn);
-  }
-  void OnWindowSharedPropertyChanged(uint32_t window,
-                                     const String& name,
-                                     Array<uint8_t> new_data) override {
-    tracker_.OnWindowSharedPropertyChanged(window, name, std::move(new_data));
-  }
-  void OnWindowInputEvent(uint32_t event_id,
-                          uint32_t window,
-                          EventPtr event) override {
-    tracker_.OnWindowInputEvent(window, std::move(event));
-  }
-  void OnWindowFocused(uint32_t focused_window_id) override {
-    tracker_.OnWindowFocused(focused_window_id);
-  }
-  void OnWindowPredefinedCursorChanged(uint32_t window_id,
-                                       mojom::Cursor cursor_id) override {
-    tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
-  }
-  void OnChangeCompleted(uint32_t change_id, bool success) override {
-    if (record_on_change_completed_)
-      tracker_.OnChangeCompleted(change_id, success);
-  }
-  void RequestClose(uint32_t window_id) override {}
-  void GetWindowManager(mojo::AssociatedInterfaceRequest<mojom::WindowManager>
-                            internal) override {}
-
-  TestChangeTracker tracker_;
-
-  mojo::Binding<mojom::WindowTreeClient> binding_;
-  bool record_on_change_completed_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClient);
-};
-
-// -----------------------------------------------------------------------------
-
-// ClientConnection implementation that vends TestWindowTreeClient.
-class TestClientConnection : public ClientConnection {
- public:
-  TestClientConnection() : ClientConnection(&client_), is_paused_(false) {}
-  ~TestClientConnection() override {}
-
-  TestWindowTreeClient* client() { return &client_; }
-
-  bool is_paused() const { return is_paused_; }
-
-  // ClientConnection:
-  mojom::WindowManager* GetWindowManager() override {
-    NOTREACHED();
-    return nullptr;
-  }
-  void SetIncomingMethodCallProcessingPaused(bool paused) override {
-    is_paused_ = paused;
-  }
-
- private:
-  TestWindowTreeClient client_;
-  bool is_paused_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestClientConnection);
-};
-
-// -----------------------------------------------------------------------------
-
-// Empty implementation of ConnectionManagerDelegate.
-class TestConnectionManagerDelegate : public ConnectionManagerDelegate {
- public:
-  TestConnectionManagerDelegate() : last_connection_(nullptr) {}
-  ~TestConnectionManagerDelegate() override {}
-
-  TestWindowTreeClient* last_client() {
-    return last_connection_ ? last_connection_->client() : nullptr;
-  }
-
-  TestClientConnection* last_connection() { return last_connection_; }
-
- private:
-  // ConnectionManagerDelegate:
-  void OnNoMoreRootConnections() override {}
-  scoped_ptr<ClientConnection> CreateClientConnectionForEmbedAtWindow(
-      ws::ConnectionManager* connection_manager,
-      ws::WindowTreeImpl* tree,
-      mojom::WindowTreeRequest tree_request,
-      mojom::WindowTreeClientPtr client) override {
-    scoped_ptr<TestClientConnection> connection(new TestClientConnection);
-    last_connection_ = connection.get();
-    return std::move(connection);
-  }
-  void CreateDefaultWindowTreeHosts() override { NOTREACHED(); }
-
-  TestClientConnection* last_connection_;
-  WindowTreeHostImpl* window_tree_host_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestConnectionManagerDelegate);
-};
-
-// -----------------------------------------------------------------------------
-
 class TestWindowTreeHostConnection : public WindowTreeHostConnection {
  public:
   TestWindowTreeHostConnection(WindowTreeHostImpl* host_impl,
                                ConnectionManager* manager)
       : host_(host_impl), connection_manager_(manager) {}
   ~TestWindowTreeHostConnection() override {}
 
  private:
   // WindowTreeHostConnection:
   WindowTreeImpl* CreateWindowTree(ServerWindow* root) override {
     return connection_manager_->EmbedAtWindow(
         root, mus::mojom::WindowTree::kAccessPolicyEmbedRoot,
         mus::mojom::WindowTreeClientPtr());
   }
 
   WindowTreeHostImpl* host_;
   ConnectionManager* connection_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeHostConnection);
 };
 
-// -----------------------------------------------------------------------------
-// Empty implementation of DisplayManager.
-class TestDisplayManager : public DisplayManager {
- public:
-  explicit TestDisplayManager(int32_t* cursor_id_storage)
-      : cursor_id_storage_(cursor_id_storage) {}
-  ~TestDisplayManager() override {}
-
-  // DisplayManager:
-  void Init(DisplayManagerDelegate* delegate) override {
-    // It is necessary to tell the delegate about the ViewportMetrics to make
-    // sure that the WindowTreeHostConnection is correctly initialized (and a
-    // root-window is created).
-    mojom::ViewportMetrics metrics;
-    metrics.size_in_pixels = mojo::Size::From(gfx::Size(400, 300));
-    metrics.device_pixel_ratio = 1.f;
-    delegate->OnViewportMetricsChanged(mojom::ViewportMetrics(), metrics);
-  }
-  void SchedulePaint(const ServerWindow* window,
-                     const gfx::Rect& bounds) override {}
-  void SetViewportSize(const gfx::Size& size) override {}
-  void SetTitle(const base::string16& title) override {}
-  void SetCapture() override {}
-  void ReleaseCapture() override {}
-  void SetCursorById(int32_t cursor) override { *cursor_id_storage_ = cursor; }
-  mojom::Rotation GetRotation() override { return mojom::Rotation::VALUE_0; }
-  const mojom::ViewportMetrics& GetViewportMetrics() override {
-    return display_metrices_;
-  }
-  void UpdateTextInputState(const ui::TextInputState& state) override {}
-  void SetImeVisibility(bool visible) override {}
-  bool IsFramePending() const override { return false; }
-  void RequestCopyOfOutput(
-      scoped_ptr<cc::CopyOutputRequest> output_request) override {}
-
- private:
-  mojom::ViewportMetrics display_metrices_;
-
-  int32_t* cursor_id_storage_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestDisplayManager);
-};
-
-// Factory that dispenses TestDisplayManagers.
-class TestDisplayManagerFactory : public DisplayManagerFactory {
- public:
-  explicit TestDisplayManagerFactory(int32_t* cursor_id_storage)
-      : cursor_id_storage_(cursor_id_storage) {}
-  ~TestDisplayManagerFactory() {}
-  DisplayManager* CreateDisplayManager(
-      mojo::Connector* connector,
-      const scoped_refptr<GpuState>& gpu_state,
-      const scoped_refptr<mus::SurfacesState>& surfaces_state) override {
-    return new TestDisplayManager(cursor_id_storage_);
-  }
-
- private:
-  int32_t* cursor_id_storage_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestDisplayManagerFactory);
-};
-
 ui::PointerEvent CreatePointerDownEvent(int x, int y) {
   return ui::PointerEvent(ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(x, y),
                                          1, ui::EventTimeForNow()));
 }
 
 ui::PointerEvent CreatePointerUpEvent(int x, int y) {
   return ui::PointerEvent(ui::TouchEvent(
       ui::ET_TOUCH_RELEASED, gfx::Point(x, y), 1, ui::EventTimeForNow()));
 }
 
@@ skipping 61 matching lines @@
   }
 
   TestWindowTreeClient* wm_client() { return wm_client_; }
   mus::mojom::Cursor cursor_id() {
     return static_cast<mus::mojom::Cursor>(cursor_id_);
   }
 
   TestWindowTreeHostConnection* host_connection() { return host_connection_; }
 
   void DispatchEventWithoutAck(const ui::Event& event) {
-    window_tree_host_->OnEvent(event);
+    WindowTreeHostTestApi(window_tree_host_).OnEvent(event);
   }
 
   void set_window_manager_internal(WindowTreeImpl* connection,
                                    mojom::WindowManager* wm_internal) {
-    connection->window_manager_internal_ = wm_internal;
+    WindowTreeTestApi(connection).set_window_manager_internal(wm_internal);
   }
 
   void AckPreviousEvent() {
-    while (window_tree_host_->tree_awaiting_input_ack_)
-      window_tree_host_->tree_awaiting_input_ack_->OnWindowInputEventAck(0);
+    WindowTreeHostTestApi test_api(window_tree_host_);
+    while (test_api.tree_awaiting_input_ack())
+      test_api.tree_awaiting_input_ack()->OnWindowInputEventAck(0);
   }
 
   void DispatchEventAndAckImmediately(const ui::Event& event) {
     DispatchEventWithoutAck(event);
     AckPreviousEvent();
   }
 
   // Creates a new window from wm_connection() and embeds a new connection in
   // it.
   void SetupEventTargeting(TestWindowTreeClient** out_client,
                            WindowTreeImpl** window_tree_connection,
                            ServerWindow** window);
 
  protected:
   // testing::Test:
   void SetUp() override {
     DisplayManager::set_factory_for_testing(&display_manager_factory_);
-    // TODO(fsamuel): This is probably broken. We need a root.
     connection_manager_.reset(
         new ConnectionManager(&delegate_, scoped_refptr<SurfacesState>()));
     window_tree_host_ = new WindowTreeHostImpl(
         connection_manager_.get(), nullptr, scoped_refptr<GpuState>(),
         scoped_refptr<mus::SurfacesState>());
-    // TODO(fsamuel): This is way too magical. We need to find a better way to
-    // manage lifetime.
     host_connection_ = new TestWindowTreeHostConnection(
         window_tree_host_, connection_manager_.get());
     window_tree_host_->Init(make_scoped_ptr(host_connection_));
     wm_client_ = delegate_.last_client();
   }
 
  protected:
   // TestWindowTreeClient that is used for the WM connection.
   TestWindowTreeClient* wm_client_;
   int32_t cursor_id_;
   TestDisplayManagerFactory display_manager_factory_;
   TestConnectionManagerDelegate delegate_;
+  // Owned by ConnectionManager.
   TestWindowTreeHostConnection* host_connection_;
   WindowTreeHostImpl* window_tree_host_ = nullptr;
   scoped_ptr<ConnectionManager> connection_manager_;
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeTest);
 };
 
 // Creates a new window in wm_connection(), adds it to the root, embeds a
 // new client in the window and creates a child of said window. |window| is
 // set to the child of |window_tree_connection| that is created.
 void WindowTreeTest::SetupEventTargeting(
     TestWindowTreeClient** out_client,
     WindowTreeImpl** window_tree_connection,
     ServerWindow** window) {
   const ClientWindowId embed_window_id =
       BuildClientWindowId(wm_connection(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRootId(wm_connection()),
                                          embed_window_id));
   window_tree_host_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
-  mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
-      GetProxy(&client);
+  mojom::WindowTreeClientRequest client_request = GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
                          mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   ServerWindow* embed_window =
       wm_connection()->GetWindowByClientId(embed_window_id);
   WindowTreeImpl* connection1 =
       connection_manager()->GetConnectionWithRoot(embed_window);
   ASSERT_TRUE(connection1 != nullptr);
@@ skipping 30 matching lines @@
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   ServerWindow* embed_window =
       wm_connection()->GetWindowByClientId(embed_window_id);
   ASSERT_TRUE(embed_window);
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_connection()));
   const ClientWindowId wm_root_id = FirstRootId(wm_connection());
   EXPECT_TRUE(wm_connection()->AddWindow(wm_root_id, embed_window_id));
   window_tree_host_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
-  mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
-      GetProxy(&client);
+  mojom::WindowTreeClientRequest client_request = GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
                          mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   WindowTreeImpl* connection1 =
       connection_manager()->GetConnectionWithRoot(embed_window);
   ASSERT_TRUE(connection1 != nullptr);
   ASSERT_NE(connection1, wm_connection());
 
@@ skipping 352 matching lines @@
 
   // Only the capture window should be able to release capture
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(root_window->id()));
   EXPECT_EQ(window, host->GetCaptureWindow());
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(window->id()));
   EXPECT_EQ(nullptr, host->GetCaptureWindow());
 }
 
+}  // namespace test
 }  // namespace ws
 }  // namespace mus