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/24 21:14:04]

Thanks for the explanation on how it's expected to work. Can you add some short
comments on the functions for when they are expected to be called? Like, it's
append, wait for embed, init right?

[fwang, 2017/02/24 21:53:45]

Done. (actually my previous comment only described the MusExternal case, the
MusInternal is simpler since you only have one window and the append/init can be
done at the same time)

   void InitWindowTreeData(
       std::unique_ptr<aura::WindowTreeHostMus> window_tree_host);
-  void CleanupWindowTreeData();
+  void RemoveWindowTreeData(aura::WindowTreeHostMus* window_tree_host);
+  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_