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

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 82 matching lines @@
 }
 
 void WindowTree::Init(std::unique_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree) {
   DCHECK(!binding_);
   binding_ = std::move(binding);
 
   if (roots_.empty())
     return;
 
+  DoOnEmbed(std::move(tree), nullptr /*ServerWindow*/);
+}
+
+void WindowTree::DoOnEmbed(mojom::WindowTreePtr tree,
+                           ServerWindow* root_window) {
   std::vector<const ServerWindow*> to_send;
-  CHECK_EQ(1u, roots_.size());
-  const ServerWindow* root = *roots_.begin();
+
+  bool in_external_window_mode = !!root_window;
+  if (in_external_window_mode)
+    CHECK_LE(1u, roots_.size());
+  else
+    CHECK_EQ(1u, roots_.size());

[fwang, 2017/03/01 06:38:47]

Does that compile when assertions are disabled?

+
+  const ServerWindow* root = root_window ? root_window : *roots_.begin();
   GetUnknownWindowsFrom(root, &to_send);
 
   Display* display = GetDisplay(root);
   int64_t display_id = display ? display->GetId() : display::kInvalidDisplayId;
   const ServerWindow* focused_window =
       display ? display->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   ClientWindowId focused_window_id;
   if (focused_window)
@@ skipping 66 matching lines @@
   return window_server_->display_manager();
 }
 
 void WindowTree::PrepareForWindowServerShutdown() {
   window_manager_internal_client_binding_.reset();
   binding_->ResetClientForShutdown();
   if (window_manager_internal_)
     window_manager_internal_ = binding_->GetWindowManager();
 }
 
-void WindowTree::AddRootForWindowManager(const ServerWindow* root) {
-  DCHECK(window_manager_internal_);
+void WindowTree::AddRoot(const ServerWindow* root) {
   const ClientWindowId client_window_id(WindowIdToTransportId(root->id()));
   DCHECK_EQ(0u, client_id_to_window_id_map_.count(client_window_id));
   client_id_to_window_id_map_[client_window_id] = root->id();
   window_id_to_client_id_map_[root->id()] = client_window_id;
   roots_.insert(root);
 
   Display* display = GetDisplay(root);
   DCHECK(display);
+}
 
-  window_manager_internal_->WmNewDisplayAdded(display->ToDisplay(),
+void WindowTree::AddRootForWindowManager(const ServerWindow* root) {
+  DCHECK(window_manager_internal_);
+  AddRoot(root);
+  window_manager_internal_->WmNewDisplayAdded(GetDisplay(root)->ToDisplay(),
                                               WindowToWindowData(root),
                                               root->parent()->IsDrawn());
 }
 
 void WindowTree::OnWindowDestroyingTreeImpl(WindowTree* tree) {
   if (event_source_wms_ && event_source_wms_->window_tree() == tree)
     event_source_wms_ = nullptr;
 
   // Notify our client if |tree| was embedded in any of our windows.
   for (const auto* tree_root : tree->roots_) {
@@ skipping 1942 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui