c++ / mojo changes for 'external window mode'

ui/aura/mus/window_tree_client.cc

 // 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.
 
 #include "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 208 matching lines @@
   client_id_ = 101;
 
   ui::mojom::WindowTreeFactoryPtr factory;
   connector_->BindInterface(ui::mojom::kServiceName, &factory);
   ui::mojom::WindowTreePtr window_tree;
   factory->CreateWindowTree(MakeRequest(&window_tree),
                             binding_.CreateInterfacePtrAndBind());
   SetWindowTree(std::move(window_tree));
 }
 
+void WindowTreeClient::ConnectViaWindowTreeHostFactory() {
+  // The client id doesn't really matter, we use 101 purely for debugging.
+  client_id_ = 101;
+
+  ui::mojom::WindowTreeHostFactoryRegistrarPtr host_factory_registrar;
+  connector_->BindInterface(ui::mojom::kServiceName, &host_factory_registrar);
+
+  ui::mojom::WindowTreePtr window_tree;
+  host_factory_registrar->Register(MakeRequest(&window_tree_host_factory_ptr_),
+                                   MakeRequest(&window_tree),
+                                   binding_.CreateInterfacePtrAndBind());
+  SetWindowTree(std::move(window_tree));
+}
+
 void WindowTreeClient::ConnectAsWindowManager() {
   DCHECK(window_manager_delegate_);
 
   ui::mojom::WindowManagerWindowTreeFactoryPtr factory;
   connector_->BindInterface(ui::mojom::kServiceName, &factory);
   ui::mojom::WindowTreePtr window_tree;
   factory->CreateWindowTree(MakeRequest(&window_tree),
                             binding_.CreateInterfacePtrAndBind());
   SetWindowTree(std::move(window_tree));
 }
 
+void WindowTreeClient::CreateHost(ui::mojom::WindowTreeHostRequest host) {
+  window_tree_host_factory_ptr_->CreateWindowTreeHost(std::move(host));

[sky, 2017/02/28 05:02:22]

I suspect that this function shouldn't be called directly. That is, when client
code creates an aura::WindowTreeHostMus the code ends up here. That's assuming
the WindowTreeclient was configured using ConnectViaWindowTreeHostFactory. If
the WindowTreeClient wasn't configured in that way then the code needs to do
what it is doing today.

[fwang, 2017/02/28 08:23:53]

Mmmh, see the changes in MusDemo for how it is used. Currently, it is the other
way around. After a call to WindowTreeClient::ConnectViaWindowTreeHostFactory(),
each WindowTreeClient::CreateHost() will create a ws::Display on the server
which will call back OnEmbed on the client (with a nullptr) and creates an
aura::WindowTreeHostMus.

[sky, 2017/02/28 17:34:09]

Sure, but doing that is awkward and inconvenient, by which I mean having to wait
for a callback before you can do anything is error prone. It would be much more
natural to create the WindowTreeHostMus and have
WindowTreeHostMus/WindowTreeClient take care of everything for you. Doing this
will work better with how views works.

[tonikitoo, 2017/03/01 05:05:44]

Hum, I believe I understand sky's point. It might require a bit of change on the
current host creation flow.

sky: Would it be possible to change it as per your request in a follow up CL, so
that we expedite moving this one forward?

[sky, 2017/03/01 17:08:38]

I would prefer we go in the right direction, which I believe is what I outlined.

+}
+
 void WindowTreeClient::SetCanFocus(Window* window, bool can_focus) {
   DCHECK(tree_);
   DCHECK(window);
   tree_->SetCanFocus(WindowMus::Get(window)->server_id(), can_focus);
 }
 
 void WindowTreeClient::SetPredefinedCursor(WindowMus* window,
                                            ui::mojom::Cursor old_cursor,
                                            ui::mojom::Cursor new_cursor) {
   DCHECK(tree_);
@@ skipping 248 matching lines @@
                                    ClientSpecificId client_id,
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   client_id_ = client_id;
   WindowTreeConnectionEstablished(window_tree);
 
-  DCHECK(roots_.empty());

[fwang, 2017/02/28 08:23:53]

Should this be kept when we do OnEmbed without configuring with
ConnectViaWindowManagerHostFactory (if that's ever possible)?

[tonikitoo, 2017/03/01 05:05:44]

From OnEmbedImpl it is a bit hard. I have moved this DCHECK to OnEmbed.

   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::EMBED, *root_data, display_id);
 
   focus_synchronizer_->SetFocusFromServer(
       GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(std::move(window_tree_host));
 }
 
 WindowTreeHostMus* WindowTreeClient::WmNewDisplayAddedImpl(
@@ skipping 313 matching lines @@
   DCHECK(tree_);
   tree_->SetEventTargetingPolicy(window->server_id(), policy);
 }
 
 void WindowTreeClient::OnEmbed(ClientSpecificId client_id,
                                ui::mojom::WindowDataPtr root_data,
                                ui::mojom::WindowTreePtr tree,
                                int64_t display_id,
                                Id focused_window_id,
                                bool drawn) {
-  DCHECK(!tree_ptr_);
-  tree_ptr_ = std::move(tree);
+  DCHECK(tree_ptr_);
+  DCHECK(!tree);
+  // No need to set 'tree_ptr_' here because it was already set during
+  // ConnectViaWindowManagerHostFactory.

[fwang, 2017/02/28 08:23:53]

What happens when we do OnEmbed without configuring with
ConnectViaWindowManagerHostFactory?

[tonikitoo, 2017/03/01 05:05:44]

Done.

 
   is_from_embed_ = true;
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(
         MakeRequest(&window_manager_internal_client_));
   }
 
   OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data), display_id,
               focused_window_id, drawn);
@@ skipping 974 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura