Adds ability for WindowManager to create display roots

services/ui/ws/test_utils.h

 // Copyright 2016 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.
 
 #ifndef SERVICES_UI_WS_TEST_UTILS_H_
 #define SERVICES_UI_WS_TEST_UTILS_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 109 matching lines @@
   void AckLastAccelerator(
       mojom::EventResult result,
       const std::unordered_map<std::string, std::vector<uint8_t>>& properties =
           std::unordered_map<std::string, std::vector<uint8_t>>()) {
     tree_->OnAcceleratorAck(tree_->event_ack_id_, result, properties);
   }
 
   void StartPointerWatcher(bool want_moves);
   void StopPointerWatcher();
 
+  bool ProcessSetDisplayRoot(int64_t display_id,
+                             const ClientWindowId& client_window_id) {
+    return tree_->ProcessSetDisplayRoot(display_id, client_window_id);
+  }
+
  private:
   WindowTree* tree_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeTestApi);
 };
 
 // -----------------------------------------------------------------------------
 
 class DisplayTestApi {
  public:
@@ skipping 80 matching lines @@
   ClientSpecificId GetEventTargetClientId(const ServerWindow* window,
                                           bool in_nonclient_area) {
     return wms_->GetEventTargetClientId(window, in_nonclient_area);
   }
 
   WindowTree* tree_awaiting_input_ack() {
     return wms_->in_flight_event_details_ ? wms_->in_flight_event_details_->tree
                                           : nullptr;
   }
 
+  const std::vector<std::unique_ptr<WindowManagerDisplayRoot>>&
+  window_manager_display_roots() const {
+    return wms_->window_manager_display_roots_;
+  }
+
  private:
   WindowManagerState* wms_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerStateTestApi);
 };
 
 // -----------------------------------------------------------------------------
 
 class DragControllerTestApi {
  public:
@@ skipping 10 matching lines @@
   DragController* op_;
 
   DISALLOW_COPY_AND_ASSIGN(DragControllerTestApi);
 };
 
 // -----------------------------------------------------------------------------
 
 // Factory that always embeds the new WindowTree as the root user id.
 class TestDisplayBinding : public DisplayBinding {
  public:
-  explicit TestDisplayBinding(WindowServer* window_server)
-      : window_server_(window_server) {}
+  explicit TestDisplayBinding(WindowServer* window_server,
+                              bool automatically_create_display_roots = true)
+      : window_server_(window_server),
+        automatically_create_display_roots_(
+            automatically_create_display_roots) {}
   ~TestDisplayBinding() override {}
 
  private:
   // DisplayBinding:
   WindowTree* CreateWindowTree(ServerWindow* root) override;
 
   WindowServer* window_server_;
+  const bool automatically_create_display_roots_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDisplayBinding);
 };
 
 // -----------------------------------------------------------------------------
 
 // Factory that dispenses TestPlatformDisplays.
 class TestPlatformDisplayFactory : public PlatformDisplayFactory {
  public:
   explicit TestPlatformDisplayFactory(mojom::CursorType* cursor_storage);
   ~TestPlatformDisplayFactory();
 
   // PlatformDisplayFactory:
   std::unique_ptr<PlatformDisplay> CreatePlatformDisplay(
       ServerWindow* root_window,
       const display::ViewportMetrics& metrics) override;
 
  private:
   mojom::CursorType* cursor_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformDisplayFactory);
 };
 
 // -----------------------------------------------------------------------------
 
 class TestWindowManager : public mojom::WindowManager {
  public:
-  TestWindowManager()
-      : got_create_top_level_window_(false),
-        change_id_(0u),
-        on_accelerator_called_(false),
-        on_accelerator_id_(0u) {}
-  ~TestWindowManager() override {}
+  TestWindowManager();
+  ~TestWindowManager() override;
 
   bool did_call_create_top_level_window(uint32_t* change_id) {
     if (!got_create_top_level_window_)
       return false;
 
     got_create_top_level_window_ = false;
     *change_id = change_id_;
     return true;
   }
 
   void ClearAcceleratorCalled() {
     on_accelerator_id_ = 0u;
     on_accelerator_called_ = false;
   }
 
   bool on_perform_move_loop_called() { return on_perform_move_loop_called_; }
   bool on_accelerator_called() { return on_accelerator_called_; }
   uint32_t on_accelerator_id() { return on_accelerator_id_; }
   bool got_display_removed() const { return got_display_removed_; }
   int64_t display_removed_id() const { return display_removed_id_; }
   bool on_set_modal_type_called() { return on_set_modal_type_called_; }
+  int connect_count() const { return connect_count_; }
+  int display_added_count() const { return display_added_count_; }
 
  private:
   // WindowManager:
-  void OnConnect(uint16_t client_id) override {}
+  void OnConnect(uint16_t client_id) override;
   void WmNewDisplayAdded(
       const display::Display& display,
       ui::mojom::WindowDataPtr root,
       bool drawn,
       const cc::FrameSinkId& frame_sink_id,
-      const base::Optional<cc::LocalSurfaceId>& local_surface_id) override {}
+      const base::Optional<cc::LocalSurfaceId>& local_surface_id) override;
   void WmDisplayRemoved(int64_t display_id) override;
   void WmDisplayModified(const display::Display& display) override {}
   void WmSetBounds(uint32_t change_id,
                    uint32_t window_id,
                    const gfx::Rect& bounds) override {}
   void WmSetProperty(
       uint32_t change_id,
       uint32_t window_id,
       const std::string& name,
       const base::Optional<std::vector<uint8_t>>& value) override {}
@@ skipping 22 matching lines @@
   void WmStackAbove(uint32_t change_id, uint32_t above_id,
                     uint32_t below_id) override;
   void WmStackAtTop(uint32_t change_id, uint32_t window_id) override;
   void OnAccelerator(uint32_t ack_id,
                      uint32_t accelerator_id,
                      std::unique_ptr<ui::Event> event) override;
 
   bool on_perform_move_loop_called_ = false;
   bool on_set_modal_type_called_ = false;
 
-  bool got_create_top_level_window_;
-  uint32_t change_id_;
+  bool got_create_top_level_window_ = false;
+  uint32_t change_id_ = 0u;
 
-  bool on_accelerator_called_;
-  uint32_t on_accelerator_id_;
+  bool on_accelerator_called_ = false;
+  uint32_t on_accelerator_id_ = 0u;
 
   bool got_display_removed_ = false;
   int64_t display_removed_id_ = 0;
 
+  int connect_count_ = 0;
+  int display_added_count_ = 0;
+
   DISALLOW_COPY_AND_ASSIGN(TestWindowManager);
 };
 
 // -----------------------------------------------------------------------------
 
 // WindowTreeClient implementation that logs all calls to a TestChangeTracker.
 class TestWindowTreeClient : public ui::mojom::WindowTreeClient {
  public:
   TestWindowTreeClient();
   ~TestWindowTreeClient() override;
@@ skipping 217 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WindowServerTestHelper);
 };
 
 // -----------------------------------------------------------------------------
 
 // Helper class which owns all of the necessary objects to test event targeting
 // of ServerWindow objects.
 class WindowEventTargetingHelper {
  public:
-  WindowEventTargetingHelper();
+  explicit WindowEventTargetingHelper(
+      bool automatically_create_display_roots = true);
   ~WindowEventTargetingHelper();
 
   // Creates |window| as an embeded window of the primary tree. This window is a
   // root window of its own tree, with bounds |window_bounds|. The bounds of the
   // root window of |display_| are defined by |root_window_bounds|.
   ServerWindow* CreatePrimaryTree(const gfx::Rect& root_window_bounds,
                                   const gfx::Rect& window_bounds);
   // Creates a secondary tree, embedded as a child of |embed_window|. The
   // resulting |window| is setup for event targeting, with bounds
   // |window_bounds|.
@@ skipping 28 matching lines @@
   Display* display_ = nullptr;
   ClientSpecificId next_primary_tree_window_id_ = 1;
 
   DISALLOW_COPY_AND_ASSIGN(WindowEventTargetingHelper);
 };
 
 // -----------------------------------------------------------------------------
 
 // Adds a new WM to |window_server| for |user_id|. Creates
 // WindowManagerWindowTreeFactory and associated WindowTree for the WM.
-void AddWindowManager(WindowServer* window_server, const UserId& user_id);
+void AddWindowManager(WindowServer* window_server,
+                      const UserId& user_id,
+                      bool automatically_create_display_roots = true);
 
 // Create a new Display object with specified origin, pixel size and device
 // scale factor. The bounds size is computed based on the pixel size and device
 // scale factor.
 display::Display MakeDisplay(int origin_x,
                              int origin_y,
                              int width_pixels,
                              int height_pixels,
                              float scale_factor);
 
 // Returns the first and only root of |tree|. If |tree| has zero or more than
 // one root returns null.
 ServerWindow* FirstRoot(WindowTree* tree);
 
 // Returns the ClientWindowId of the first root of |tree|, or an empty
 // ClientWindowId if |tree| has zero or more than one root.
 ClientWindowId FirstRootId(WindowTree* tree);
 
 // Returns |tree|s ClientWindowId for |window|.
 ClientWindowId ClientWindowIdForWindow(WindowTree* tree,
                                        const ServerWindow* window);
 
 // Creates a new visible window as a child of the single root of |tree|.
 // |client_id| is set to the ClientWindowId of the new window.
-ServerWindow* NewWindowInTree(WindowTree* tree, ClientWindowId* client_id);
+ServerWindow* NewWindowInTree(WindowTree* tree,
+                              ClientWindowId* client_id = nullptr);
 ServerWindow* NewWindowInTreeWithParent(WindowTree* tree,
                                         ServerWindow* parent,
                                         ClientWindowId* client_id = nullptr);
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_TEST_UTILS_H_