cc: Register namespace hierarchy after ui::Compositor's SurfaceFactory available

ui/compositor/compositor.cc

 // Copyright (c) 2012 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/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 227 matching lines @@
 
   if (animation_timeline_)
     host_->animation_host()->RemoveAnimationTimeline(animation_timeline_.get());
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
   host_.reset();
 
   context_factory_->RemoveCompositor(this);
   if (context_factory_->GetSurfaceManager()) {
+    for (auto& client : surface_clients_) {
+      if (client.second) {
+        context_factory_->GetSurfaceManager()
+            ->UnregisterSurfaceNamespaceHierarchy(client.second, client.first);
+      }
+    }
     context_factory_->GetSurfaceManager()->InvalidateSurfaceClientId(
         surface_id_allocator_->client_id());
   }
 }
 
+void Compositor::AddSurfaceClient(uint32_t client_id) {
+  // We don't give the client a parent until the ui::Compositor has an
+  // OutputSurface.
+  uint32_t parent_client_id = 0;
+  if (host_->has_output_surface()) {
+    parent_client_id = surface_id_allocator_->client_id();
+    context_factory_->GetSurfaceManager()->RegisterSurfaceNamespaceHierarchy(
+        parent_client_id, client_id);
+  }
+  surface_clients_[client_id] = parent_client_id;
+}
+
+void Compositor::RemoveSurfaceClient(uint32_t client_id) {
+  auto it = surface_clients_.find(client_id);
+  DCHECK(it != surface_clients_.end());
+  if (host_->has_output_surface()) {
+    context_factory_->GetSurfaceManager()->UnregisterSurfaceNamespaceHierarchy(
+        it->second, client_id);
+  }
+  surface_clients_.erase(it);
+}
+
 void Compositor::SetOutputSurface(
     std::unique_ptr<cc::OutputSurface> output_surface) {
   output_surface_requested_ = false;
   host_->SetOutputSurface(std::move(output_surface));
+  // ui::Compositor uses a SingleThreadProxy and so BindToClient will be called
+  // above and SurfaceManager will be made aware of the OutputSurface's client
+  // ID.
+  for (auto& client : surface_clients_) {
+    if (client.second == surface_id_allocator_->client_id())
+      continue;
+    // If a client already has a parent, then we unregister the existing parent.
+    if (client.second) {
+      context_factory_->GetSurfaceManager()
+          ->UnregisterSurfaceNamespaceHierarchy(client.second, client.first);
+    }
+    context_factory_->GetSurfaceManager()->RegisterSurfaceNamespaceHierarchy(
+        surface_id_allocator_->client_id(), client.first);
+    client.second = surface_id_allocator_->client_id();
+  }
 }
 
 void Compositor::ScheduleDraw() {
   host_->SetNeedsCommit();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
@@ skipping 89 matching lines @@
   // This function should only get called once.
   DCHECK(!widget_valid_);
   widget_ = widget;
   widget_valid_ = true;
   if (output_surface_requested_)
     context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr());
 }
 
 gfx::AcceleratedWidget Compositor::ReleaseAcceleratedWidget() {
   DCHECK(!IsVisible());
-  if (!host_->output_surface_lost())
+  if (!host_->output_surface_lost()) {
     host_->ReleaseOutputSurface();
+    for (auto& client : surface_clients_) {
+      context_factory_->GetSurfaceManager()
+          ->UnregisterSurfaceNamespaceHierarchy(client.second, client.first);
+      client.second = 0;
+    }
+  }
   context_factory_->RemoveCompositor(this);
   widget_valid_ = false;
   gfx::AcceleratedWidget widget = widget_;
   widget_ = gfx::kNullAcceleratedWidget;
   return widget;
 }
 
 gfx::AcceleratedWidget Compositor::widget() const {
   DCHECK(widget_valid_);
   return widget_;
@@ skipping 132 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui