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

services/ui/ws/display.cc

 // Copyright 2015 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 "services/ui/ws/display.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/focus_controller.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/platform_display_init_params.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree.h"
 #include "services/ui/ws/window_tree_binding.h"
+#include "services/ui/ws/window_tree_host_factory.h"
 #include "ui/base/cursor/cursor.h"
 
 namespace ui {
 namespace ws {
 
 Display::Display(WindowServer* window_server)
     : window_server_(window_server), last_cursor_(mojom::Cursor::CURSOR_NULL) {
   window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
@@ skipping 16 matching lines @@
     // If there is a |binding_| then the tree was created specifically for this
     // display (which corresponds to a WindowTreeHost).
     window_server_->DestroyTree(window_manager_display_root_map_.begin()
                                     ->second->window_manager_state()
                                     ->window_tree());
   }
 }
 
 void Display::Init(const PlatformDisplayInitParams& init_params,
                    std::unique_ptr<DisplayBinding> binding) {
+  if (window_server_->IsInExternalWindowMode())
+    DCHECK(window_server_->window_tree_host_factory() && binding);

[kylechar, 2017/03/07 18:19:37]

DCHECKs are compiled out in release builds, that might cause problems with the
if statement.

[tonikitoo, 2017/03/07 20:09:36]

BuildBots (including release bots) seem happy, but if you think it looks odd, I
can try it differently.

+
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
 
   CreateRootWindow(init_params.metrics.pixel_size);
   PlatformDisplayInitParams params_copy = init_params;
   params_copy.root_window = root_.get();
 
   platform_display_ = PlatformDisplay::Create(params_copy);
   platform_display_->Init(this);
 }
@@ skipping 122 matching lines @@
 }
 
 void Display::SetSize(const gfx::Size& size) {
   platform_display_->SetViewportSize(size);
 }
 
 void Display::SetTitle(const std::string& title) {
   platform_display_->SetTitle(base::UTF8ToUTF16(title));
 }
 
+void Display::InitDisplayRoot() {
+  DCHECK(window_server_->IsInExternalWindowMode());
+  DCHECK(window_server_->window_tree_host_factory());
+  DCHECK(binding_);
+
+  external_window_mode_display_root_ =
+      base::MakeUnique<WindowManagerDisplayRoot>(this);
+  window_manager_display_root_map_[service_manager::mojom::kRootUserID] =

[kylechar, 2017/03/07 18:19:37]

Once you aren't using WindowManagerDisplayRoot anymore in external mode, you
also wouldn't use this map, right?

[tonikitoo, 2017/03/07 20:09:36]

This is still needed, but should be clean up indeed. Will add a TODO.

When WindowTree::AddWindow is called, this calling out one the methods in
ws::Display that still need this map to be filled up.

+      external_window_mode_display_root_.get();
+
+  ServerWindow* server_window = external_window_mode_display_root_->root();
+  WindowTree* window_tree =
+      window_server_->window_tree_host_factory()->window_tree();
+  window_tree->AddRoot(server_window);
+  window_tree->DoOnEmbed(nullptr /*mojom::WindowTreePtr*/, server_window);
+}
+
 void Display::InitWindowManagerDisplayRoots() {
+  // Tests can create ws::Display instances, directly by-passing

[kylechar, 2017/03/07 18:19:37]

The if (binding_) path is only for tests now?

[tonikitoo, 2017/03/07 20:09:36]

Yes and No.

Yes, because I believe only tests exercise this path today.
No, because one can still call WindowTreeHostFactory::CreateWindowTreeHost
directly, and end up here.
This won't be in 'external window mode' though.

I left this existing code path untouched not to break existing tests, and if we
decide to change/remove it in the future, we should do it altogether.

+  // WindowTreeHostFactory.
   if (binding_) {
     std::unique_ptr<WindowManagerDisplayRoot> display_root_ptr(
         new WindowManagerDisplayRoot(this));
     WindowManagerDisplayRoot* display_root = display_root_ptr.get();
     // For this case we never create additional displays roots, so any
     // id works.
     window_manager_display_root_map_[service_manager::mojom::kRootUserID] =
         display_root_ptr.get();
     WindowTree* window_tree = binding_->CreateWindowTree(display_root->root());
     display_root->window_manager_state_ = window_tree->window_manager_state();
     window_tree->window_manager_state()->AddWindowManagerDisplayRoot(
         std::move(display_root_ptr));
   } else {
     CreateWindowManagerDisplayRootsFromFactories();
   }
-  display_manager()->OnDisplayUpdate(this);
 }
 
 void Display::CreateWindowManagerDisplayRootsFromFactories() {
   std::vector<WindowManagerWindowTreeFactory*> factories =
       window_server_->window_manager_window_tree_factory_set()->GetFactories();
   for (WindowManagerWindowTreeFactory* factory : factories) {
     if (factory->window_tree())
       CreateWindowManagerDisplayRootFromFactory(factory);
   }
 }
@@ skipping 33 matching lines @@
 display::Display Display::GetDisplay() {
   return ToDisplay();
 }
 
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
 void Display::OnAcceleratedWidgetAvailable() {
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
-  InitWindowManagerDisplayRoots();
+
+  if (window_server_->IsInExternalWindowMode())
+    InitDisplayRoot();
+  else
+    InitWindowManagerDisplayRoots();
+
+  display_manager()->OnDisplayUpdate(this);
 }
 
 bool Display::IsInHighContrastMode() {
   return window_server_->IsActiveUserInHighContrastMode();
 }
 
 void Display::OnEvent(const ui::Event& event) {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
-  if (display_root)
+  if (display_root && display_root->window_manager_state())
     display_root->window_manager_state()->ProcessEvent(event, GetId());
   window_server_
       ->GetUserActivityMonitorForUser(
           window_server_->user_id_tracker()->active_id())
       ->OnUserActivity();
 }
 
 void Display::OnNativeCaptureLost() {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
-  if (display_root)
+  if (display_root && display_root->window_manager_state())
     display_root->window_manager_state()->SetCapture(nullptr, kInvalidClientId);
 }
 
 void Display::OnViewportMetricsChanged(
     const display::ViewportMetrics& metrics) {
   if (root_->bounds().size() == metrics.pixel_size)
     return;
 
   gfx::Rect new_bounds(metrics.pixel_size);
   root_->SetBounds(new_bounds);
@@ skipping 62 matching lines @@
     if (embedded_tree_new && embedded_tree_new != owning_tree_old &&
         embedded_tree_new != embedded_tree_old) {
       DCHECK_NE(owning_tree_new, embedded_tree_new);
       embedded_tree_new->ProcessFocusChanged(old_focused_window,
                                              new_focused_window);
     }
   }
 
   // WindowManagers are always notified of focus changes.
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
-  if (display_root) {
+  if (display_root && display_root->window_manager_state()) {
     WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
     if (wm_tree != owning_tree_old && wm_tree != embedded_tree_old &&
         wm_tree != owning_tree_new && wm_tree != embedded_tree_new) {
       wm_tree->ProcessFocusChanged(old_focused_window, new_focused_window);
     }
   }
 
   UpdateTextInputState(new_focused_window,
                        new_focused_window->text_input_state());
 }
 
 void Display::OnUserIdRemoved(const UserId& id) {
   window_manager_display_root_map_.erase(id);
 }
 
 void Display::OnWindowManagerWindowTreeFactoryReady(
     WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
     CreateWindowManagerDisplayRootFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace ui