Move FrameSink hierarchy registration to DisplayCompositor interface

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/memory/ptr_util.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),
+      frame_sink_id_(WindowIdToTransportId(id), 0),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       is_modal_(false),
       visible_(false),
       // Default to POINTER as CURSOR_NULL doesn't change the cursor, it leaves
       // the last non-null cursor.
       cursor_id_(mojom::Cursor::POINTER),
       non_client_cursor_id_(mojom::Cursor::POINTER),
       opacity_(1),
@@ skipping 71 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) {
   // We assume validation checks happened else where.
   DCHECK(child);
   DCHECK(child != this);
   DCHECK(child->parent() == this);
 
   for (auto& observer : child->observers_)
     observer.OnWillChangeWindowHierarchy(child, nullptr, this);
 
   RemoveImpl(child);
 
-  if (GetRoot() != nullptr)
-    child->ProcessRootChanged(GetRoot(), nullptr);
-
   // 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, nullptr, this);
 }
 
 void ServerWindow::Reorder(ServerWindow* relative,
@@ skipping 259 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 29 matching lines @@
   window->OnStackingChanged();
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
 }  // namespace ui