Fixes bug in ServerWindowCompositorFrameSinkManager

services/ui/ws/server_window.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/server_window.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "services/ui/common/transient_window_utils.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/server_window_observer.h"
 
 namespace ui {
-
 namespace ws {
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate, const WindowId& id)
     : ServerWindow(delegate, id, Properties()) {}
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate,
                            const WindowId& id,
                            const Properties& properties)
     : delegate_(delegate),
       id_(id),
@@ skipping 79 matching lines @@
     if (children_.size() == 1)
       return;  // Already in the right position.
     child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
     return;
   }
 
   ServerWindow* old_parent = child->parent();
   for (auto& observer : child->observers_)
     observer.OnWillChangeWindowHierarchy(child, this, old_parent);
 
+  ServerWindow* old_root = child->GetRoot();
+  ServerWindow* new_root = GetRoot();
+
   if (child->parent())
     child->parent()->RemoveImpl(child);
 
   child->parent_ = this;
   children_.push_back(child);
 
+  if (old_root != new_root)
+    child->ProcessRootChanged(old_root, new_root);
+
   // Stack the child properly if it is a transient child of a sibling.
   if (child->transient_parent_ && child->transient_parent_->parent() == this)
     RestackTransientDescendants(child->transient_parent_, &GetStackingTarget,
                                 &ReorderImpl);
 
   for (auto& observer : child->observers_)
     observer.OnWindowHierarchyChanged(child, this, old_parent);
 }
 
 void ServerWindow::Remove(ServerWindow* child) {
@@ skipping 278 matching lines @@
   for (const ServerWindow* child : children_)
     child->BuildDebugInfo(depth + "  ", result);
 }
 #endif
 
 void ServerWindow::RemoveImpl(ServerWindow* window) {
   window->parent_ = nullptr;
   children_.erase(std::find(children_.begin(), children_.end(), window));
 }
 
+void ServerWindow::ProcessRootChanged(ServerWindow* old_root,
+                                      ServerWindow* new_root) {
+  if (compositor_frame_sink_manager_)
+    compositor_frame_sink_manager_->OnRootChanged(old_root, new_root);
+  for (ServerWindow* child : children_)
+    child->ProcessRootChanged(old_root, new_root);
+}
+
 void ServerWindow::OnStackingChanged() {
   if (stacking_target_) {
     Windows::const_iterator window_i = std::find(
         parent()->children().begin(), parent()->children().end(), this);
     DCHECK(window_i != parent()->children().end());
     if (window_i != parent()->children().begin() &&
         (*(window_i - 1) == stacking_target_)) {
       return;
     }
   }
@@ skipping 28 matching lines @@
     observer.OnWindowReordered(window, relative, direction);
   window->OnStackingChanged();
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
-
 }  // namespace ui