Mus Demo: Refactor code to prepare multiple windows in external mode

services/ui/demo/mus_demo.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_DEMO_MUS_DEMO_H_
 #define SERVICES_UI_DEMO_MUS_DEMO_H_
 
 #include <memory>
 
 #include "base/callback.h"
@@ skipping 26 matching lines @@
 // the window. Provides a simple way to demonstrate that the graphic stack works
 // as intended.
 class MusDemo : public service_manager::Service,
                 public aura::WindowTreeClientDelegate {
  public:
   MusDemo();
   ~MusDemo() override;
 
  protected:
   void AddPrimaryDisplay(const display::Display& display);
+  void AppendWindowTreeData(std::unique_ptr<WindowTreeData> window_tree_data);

[kylechar, 2017/02/23 22:45:30]

Can you walk me through the flow of how this is supposed to work?

[fwang, 2017/02/24 10:08:50]

Sure. This is explained in a comment above window_tree_data_list_, in
MusDemoExternal::OnStartImpl and MusDemoExternal::OnEmbed. But to give more
details, we starts with an empty vector of WindowTreeData. OnStartImpl calls
AppendWindowTreeData to append one WindowTreeData, which makes a Mojo call to
CreateWindowTreeHost and gets an associated WindowTreeHostPtr. On the the ws
side, this causes the following execution stack:

ui::ws::WindowTree::Init()
ui::ws::WindowServer::AddTree()
ui::ws::WindowServer::EmbedAtWindow()
ui::ws::DisplayBindingImpl::CreateWindowTree()
ui::ws::Display::InitWindowManagerDisplayRoots()
ui::ws::Display::OnAcceleratedWidgetAvailable()
ui::ws::PlatformDisplayDefault::OnAcceleratedWidgetAvailable()
ui::X11WindowBase::Create()
ui::X11WindowBase::Show()
ui::ws::PlatformDisplayDefault::Init()
ui::ws::Display::Init()
ui::ws::WindowTreeHostFactory::CreateWindowTreeHost()

Then ui::ws::WindowTree::Init makes a Mojo call to OnEmbed back to the
aura::WindowTreeClient, which leads to the following execution stack:

ui::demo::MusDemoExternal::OnEmbed()
aura::WindowTreeClient::OnEmbedImpl()
aura::WindowTreeClient::OnEmbed()

Finally, OnEmbed() makes a call to InitWindowTreeData to associate the
WindowTreeHostMus to the last appended WindowTreeData. It calls
AppendWindowTreeData and the same process starts again with a second window, a
third window and so on until we have the desired number of windows.

Two important comments:

* This mechanism ensures that the WindowTreeData have matching WindowTreeHostPtr
and WindowTreeHostMus. It's not clear to me whether we actually want to keep the
Mojo pointer to WindowTreeHostMus (for example to test SetSize or SetTitle?). If
not, I believe we could just do all Mojo calls to CreateWindowTreeHost in one go
and do append+init (which would then just be one function) WindowTreeData in
OnEmbed. That would make things much simpler!

* As explained by sky, we need a single WindowClientTree/WindowTree for all all
the data otherwise this won't work for multiple windows. Antonio is working on a
new WindowClientTree API for that purpose
(https://bugs.chromium.org/p/chromium/issues/detail?id=666958#c20). When this is
ready, we could just do window_tree_client()->ConnectViaWindowTreeHostFactory()
and window_tree_client()->CreateWindowTreeHost(MakeRequest(&host_)). This will
allow to get rid of the window_tree_host_factory_ and tree_client_ Mojo
pointers.

   void InitWindowTreeData(
       std::unique_ptr<aura::WindowTreeHostMus> window_tree_host);
-  void CleanupWindowTreeData();
+  void RemoveWindowTreeDataFor(aura::WindowTreeHostMus* window_tree_host);

[kylechar, 2017/02/23 22:45:30]

nit: RemoveWindowTreeData maybe?

[fwang, 2017/02/24 10:08:50]

Antonio suggested to change to RemoveWindowTreeDataFor, because it's not really
symmetric to AppendWindowTreeData(data). Either option will work for me.

[fwang, 2017/02/24 10:40:10]

Done.

+  aura::WindowTreeClient* window_tree_client() {
+    return window_tree_client_.get();
+  }
 
  private:
-  virtual void OnStartImpl(
-      std::unique_ptr<aura::WindowTreeClient>* window_tree_client,
-      std::unique_ptr<WindowTreeData>* window_tree_data) = 0;
+  virtual void OnStartImpl() = 0;
+  virtual std::unique_ptr<aura::WindowTreeClient> CreateWindowTreeClient() = 0;
+  bool HasPendingWindowTreeData() const;
 
   // service_manager::Service:
   void OnStart() override;
   bool OnConnect(const service_manager::ServiceInfo& remote_info,
                  service_manager::InterfaceRegistry* registry) override;
 
   // aura::WindowTreeClientDelegate:
   void OnEmbed(
       std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) override;
   void OnUnembed(aura::Window* root) override;
   void OnEmbedRootDestroyed(aura::WindowTreeHostMus* window_tree_host) override;
   void OnLostConnection(aura::WindowTreeClient* client) override;
   void OnPointerEventObserved(const ui::PointerEvent& event,
                               aura::Window* target) override;
   aura::PropertyConverter* GetPropertyConverter() override;
 
   std::unique_ptr<aura::WindowTreeClient> window_tree_client_;
   std::unique_ptr<aura::Env> env_;
   std::unique_ptr<display::ScreenBase> screen_;
 
   std::unique_ptr<aura::client::DefaultCaptureClient> capture_client_;
   std::unique_ptr<::wm::WMState> wm_state_;
   std::unique_ptr<aura::PropertyConverter> property_converter_;
 
-  std::unique_ptr<WindowTreeData> window_tree_data_;
+  // List of WindowTreeData structures. When a new window is opened, its data
+  // is appended at the end of that list and it remains uninitialized until the
+  // next call to InitWindowTreeData.
+  std::vector<std::unique_ptr<WindowTreeData>> window_tree_data_list_;
 
   DISALLOW_COPY_AND_ASSIGN(MusDemo);
 };
 
 }  // namespace demo
 }  // namespace ui
 
 #endif  // SERVICES_UI_DEMO_MUS_DEMO_H_