Changes how window manager obtains WindowTree from mus

components/mus/public/cpp/window_tree_client.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_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_
 #define COMPONENTS_MUS_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "components/mus/common/types.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
+namespace display {
+class Display;
+}
+
 namespace gfx {
 class Insets;
 class Size;
 }
 
 namespace shell {
 class Connector;
 }
 
 namespace mus {
 class InFlightChange;
 class WindowTreeClientDelegate;
 class WindowTreeClientPrivate;
 class WindowTreeClientObserver;
 enum class ChangeType;
 
-// Manages the connection with the Window Server service.
+// Manages the connection with mus.
+//
+// WindowTreeClient is deleted by any of the following:
+// . If all the roots of the connection are destroyed and the connection is
+//   configured to delete when there are no roots (true if the WindowTreeClient
+//   is created with a mojom::WindowTreeClientRequest). This happens
+//   if the owner of the roots Embed()s another app in all the roots, or all
+//   the roots are explicitly deleted.
+// . The connection to mus is lost.
+// . Explicitly by way of calling delete.
+//
+// When WindowTreeClient is deleted all windows are deleted (and observers
+// notified). This is followed by calling
+// WindowTreeClientDelegate::OnWindowTreeClientDestroyed().
 class WindowTreeClient : public mojom::WindowTreeClient,
                          public mojom::WindowManager,
                          public WindowManagerClient {
  public:
   WindowTreeClient(WindowTreeClientDelegate* delegate,
                    WindowManagerDelegate* window_manager_delegate,
                    mojom::WindowTreeClientRequest request);
   ~WindowTreeClient() override;
 
   // Establishes the connection by way of the WindowTreeFactory.
   void ConnectViaWindowTreeFactory(shell::Connector* connector);
 
+  // Establishes the connection by way of WindowManagerWindowTreeFactory.
+  void ConnectAsWindowManager(shell::Connector* connector);
+
   // Wait for OnEmbed(), returning when done.
   void WaitForEmbed();
 
   bool connected() const { return tree_ != nullptr; }
   ClientSpecificId client_id() const { return client_id_; }
 
   // API exposed to the window implementations that pushes local changes to the
   // service.
   void DestroyWindow(Window* window);
 
@@ skipping 134 matching lines @@
 
   // Returns true if there is an InFlightChange that matches |change|. If there
   // is an existing change SetRevertValueFrom() is invoked on it. Returns false
   // if there is no InFlightChange matching |change|.
   // See InFlightChange for details on how InFlightChanges are used.
   bool ApplyServerChangeToExistingInFlightChange(const InFlightChange& change);
 
   Window* NewWindowImpl(NewWindowType type,
                         const Window::SharedProperties* properties);
 
+  // Sets the mojom::WindowTree implementation.
+  void SetWindowTree(mojom::WindowTreePtr window_tree_ptr);
+
+  // Called when the mojom::WindowTree connection is lost, deletes this.
+  void OnConnectionLost();
+
   // OnEmbed() calls into this. Exposed as a separate function for testing.
   void OnEmbedImpl(mojom::WindowTree* window_tree,
                    ClientSpecificId client_id,
                    mojom::WindowDataPtr root_data,
                    int64_t display_id,
                    Id focused_window_id,
                    bool drawn);
 
+  // Called by WmNewDisplayAdded().
+  void WmNewDisplayAddedImpl(const display::Display& display,
+                             mojom::WindowDataPtr root_data,
+                             bool parent_drawn);
+
   void OnReceivedCursorLocationMemory(mojo::ScopedSharedBufferHandle handle);
 
   // Overridden from WindowTreeClient:
   void OnEmbed(ClientSpecificId client_id,
                mojom::WindowDataPtr root,
                mojom::WindowTreePtr tree,
                int64_t display_id,
                Id focused_window_id,
                bool drawn) override;
   void OnEmbeddedAppDisconnected(Id window_id) override;
@@ skipping 39 matching lines @@
                        uint32_t event_observer_id) override;
   void OnWindowFocused(Id focused_window_id) override;
   void OnWindowPredefinedCursorChanged(Id window_id,
                                        mojom::Cursor cursor) override;
   void OnChangeCompleted(uint32_t change_id, bool success) override;
   void RequestClose(uint32_t window_id) override;
   void GetWindowManager(
       mojo::AssociatedInterfaceRequest<WindowManager> internal) override;
 
   // Overridden from WindowManager:
+  void OnConnect(ClientSpecificId client_id) override;
+  void WmNewDisplayAdded(mojom::DisplayPtr display,
+                         mojom::WindowDataPtr root_data,
+                         bool parent_drawn) override;
   void WmSetBounds(uint32_t change_id,
                    Id window_id,
                    const gfx::Rect& transit_bounds) override;
   void WmSetProperty(uint32_t change_id,
                      Id window_id,
                      const mojo::String& name,
                      mojo::Array<uint8_t> transit_data) override;
   void WmCreateTopLevelWindow(uint32_t change_id,
                               ClientSpecificId requesting_client_id,
                               mojo::Map<mojo::String, mojo::Array<uint8_t>>
@@ skipping 73 matching lines @@
   uint32_t event_observer_id_ = 0u;
 
   base::WeakPtrFactory<WindowTreeClient> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClient);
 };
 
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_