Changes how window manager obtains WindowTree from mus

components/mus/ws/window_server.h

 // 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.
 
 #ifndef COMPONENTS_MUS_WS_WINDOW_SERVER_H_
 #define COMPONENTS_MUS_WS_WINDOW_SERVER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
-#include "components/mus/public/interfaces/window_manager_factory.mojom.h"
+#include "components/mus/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_manager_delegate.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/user_id_tracker.h"
-#include "components/mus/ws/window_manager_factory_registry.h"
+#include "components/mus/ws/window_manager_window_tree_factory_set.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace mus {
 namespace ws {
 
 class AccessPolicy;
 class DisplayManager;
 class ServerWindow;
 class WindowManagerState;
@@ skipping 14 matching lines @@
   WindowServerDelegate* delegate() { return delegate_; }
 
   UserIdTracker* user_id_tracker() { return &user_id_tracker_; }
   const UserIdTracker* user_id_tracker() const { return &user_id_tracker_; }
 
   DisplayManager* display_manager() { return display_manager_.get(); }
   const DisplayManager* display_manager() const {
     return display_manager_.get();
   }
 
+  bool created_one_display() const { return created_one_display_; }
+
   // Creates a new ServerWindow. The return value is owned by the caller, but
   // must be destroyed before WindowServer.
   ServerWindow* CreateServerWindow(
       const WindowId& id,
       const std::map<std::string, std::vector<uint8_t>>& properties);
 
   // Returns the id for the next WindowTree.
   ClientSpecificId GetAndAdvanceNextClientId();
 
   // See description of WindowTree::Embed() for details. This assumes
   // |transport_window_id| is valid.
   WindowTree* EmbedAtWindow(ServerWindow* root,
                             const UserId& user_id,
                             mojom::WindowTreeClientPtr client,
                             std::unique_ptr<AccessPolicy> access_policy);
 
   // Adds |tree_impl_ptr| to the set of known trees. Use DestroyTree() to
   // destroy the tree.
-  WindowTree* AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
-                      std::unique_ptr<WindowTreeBinding> binding,
-                      mojom::WindowTreePtr tree_ptr);
-  WindowTree* CreateTreeForWindowManager(Display* display,
-                                         mojom::WindowManagerFactory* factory,
-                                         ServerWindow* root,
-                                         const UserId& user_id);
+  void AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
+               std::unique_ptr<WindowTreeBinding> binding,
+               mojom::WindowTreePtr tree_ptr);
+  WindowTree* CreateTreeForWindowManager(
+      const UserId& user_id,
+      mojom::WindowTreeRequest window_tree_request,
+      mojom::WindowTreeClientPtr window_tree_client);
   // Invoked when a WindowTree's connection encounters an error.
   void DestroyTree(WindowTree* tree);
 
   // Returns the tree by client id.
   WindowTree* GetTreeWithId(ClientSpecificId client_id);
 
   WindowTree* GetTreeWithClientName(const std::string& client_name);
 
   size_t num_trees() const { return tree_map_.size(); }
 
@@ skipping 21 matching lines @@
   // Returns true if OnTreeMessagedClient() was invoked for id.
   bool DidTreeMessageClient(ClientSpecificId id) const;
 
   // Returns the WindowTree that has |id| as a root.
   WindowTree* GetTreeWithRoot(const ServerWindow* window) {
     return const_cast<WindowTree*>(
         const_cast<const WindowServer*>(this)->GetTreeWithRoot(window));
   }
   const WindowTree* GetTreeWithRoot(const ServerWindow* window) const;
 
-  void OnFirstWindowManagerFactorySet();
+  void OnFirstWindowManagerWindowTreeFactoryReady();
 
-  WindowManagerFactoryRegistry* window_manager_factory_registry() {
-    return &window_manager_factory_registry_;
+  WindowManagerWindowTreeFactorySet* window_manager_window_tree_factory_set() {
+    return &window_manager_window_tree_factory_set_;
   }
 
   // Sets focus to |window|. Returns true if |window| already has focus, or
   // focus was successfully changed. Returns |false| if |window| is not a valid
   // window to receive focus.
   bool SetFocusedWindow(ServerWindow* window);
   ServerWindow* GetFocusedWindow();
 
   // Returns a change id for the window manager that is associated with
   // |source| and |client_change_id|. When the window manager replies
@@ skipping 161 matching lines @@
 
   // Maps from window manager change id to the client that initiated the
   // request.
   InFlightWindowManagerChangeMap in_flight_wm_change_map_;
 
   // Next id supplied to the window manager.
   uint32_t next_wm_change_id_;
 
   base::Callback<void(ServerWindow*)> window_paint_callback_;
 
-  WindowManagerFactoryRegistry window_manager_factory_registry_;
+  WindowManagerWindowTreeFactorySet window_manager_window_tree_factory_set_;
+
+  // TODO(sky): remove this, temporary until window manager state made global
+  // and not per display.
+  bool created_one_display_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(WindowServer);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_WINDOW_SERVER_H_