Implement temporary reference assignment with DisplayCompositor.

services/ui/ws/window_server.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_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 588 matching lines @@
   event_dispatcher->UpdateNonClientAreaForCurrentWindow();
   display_root->display()->UpdateNativeCursor(
       event_dispatcher->GetCurrentMouseCursor());
 }
 
 bool WindowServer::IsUserInHighContrastMode(const UserId& user) const {
   const auto iter = high_contrast_mode_.find(user);
   return (iter == high_contrast_mode_.end()) ? false : iter->second;
 }
 
+void WindowServer::ClaimTemporaryReference(ServerWindow* window,
+                                           const cc::SurfaceId& surface_id) {
+  const ClientSpecificId window_client_id = window->id().client_id;
+
+  // Find the first parent window owned by a different client. Since it is a
+  // a different client, it will need to have a CompositorFrameSink in order to
+  // embed |window|.
+  ServerWindow* current = window->parent();
+  while (current && current->id().client_id == window_client_id)
+    current = current->parent();
+
+  // The client that embeds |window| is expected to submit a CompositorFrame
+  // that references |surface_id|. Have the parent claim ownership of the
+  // temporary reference to |surface_id|. If the parent client crashes before it
+  // adds a surface reference then the GPU can cleanup temporary references. If
+  // no parent client embeds |window| then tell the GPU to drop the temporary
+  // reference immediately.
+  if (current) {
+    current->GetOrCreateCompositorFrameSinkManager()->ClaimTemporaryReference(
+        surface_id);
+  } else {
+    display_compositor_->DropTemporaryReference(surface_id);
+  }
+}
+
 ServerWindow* WindowServer::GetRootWindow(const ServerWindow* window) {
   Display* display = display_manager_->GetDisplayContaining(window);
   return display ? display->root_window() : nullptr;
 }
 
 void WindowServer::OnWindowDestroyed(ServerWindow* window) {
   ProcessWindowDeleted(window);
 }
 
 void WindowServer::OnWillChangeWindowHierarchy(ServerWindow* window,
@@ skipping 144 matching lines @@
   // If we're deleting a window, then this is a superfluous message.
   if (current_operation_type() == OperationType::DELETE_WINDOW)
     return;
   for (auto& pair : tree_map_) {
     pair.second->ProcessTransientWindowRemoved(window, transient_child,
                                                IsOperationSource(pair.first));
   }
 }
 
 void WindowServer::OnGpuServiceInitialized() {
-  // TODO(kylechar): When gpu channel is removed, this can instead happen
-  // earlier, after GpuHost::OnInitialized().
   delegate_->StartDisplayInit();
 }
 
 void WindowServer::OnSurfaceCreated(const cc::SurfaceInfo& surface_info) {
   WindowId window_id(
       WindowIdFromTransportId(surface_info.id().frame_sink_id().client_id()));
   ServerWindow* window = GetWindow(window_id);
+
   // If the window doesn't have a parent then we have nothing to propagate.
-  if (!window)
+  if (!window) {
+    display_compositor_->DropTemporaryReference(surface_info.id());
     return;
+  }
 
-  // FrameGenerator will add an appropriate reference for the new surface.
   DCHECK(display_manager_->GetDisplayContaining(window));
   auto* display = display_manager_->GetDisplayContaining(window);
   if (window == display->GetActiveRootWindow()) {
+    // FrameGenerator will add an appropriate reference for the new surface.
     display->platform_display()->GetFrameGenerator()->OnSurfaceCreated(
         surface_info);
+
+    display->root_window()
+        ->GetOrCreateCompositorFrameSinkManager()
+        ->ClaimTemporaryReference(surface_info.id());
+  } else {
+    ClaimTemporaryReference(window, surface_info.id());

[Fady Samuel, 2017/03/01 16:07:46]

Can't we generalize this to be a single code path for ClaimTemporaryReference?

[Fady Samuel, 2017/03/01 17:08:27]

Or at least add a comment explaining why this is a special case.

[kylechar, 2017/03/01 17:15:23]

I'll add a comment with why. The client_id doesn't change from display root
(0:2) to the WM root (0:3) like it does for other clients.

   }
 
   // This is only used for testing to observe that a window has a
   // CompositorFrame.
   if (!window_paint_callback_.is_null())
     window_paint_callback_.Run(window);
 
   if (!window->parent())
     return;
 
   WindowTree* window_tree = GetTreeWithId(window->parent()->id().client_id);
   if (window_tree)
     window_tree->ProcessWindowSurfaceChanged(window, surface_info);
 }
 
 void WindowServer::OnActiveUserIdChanged(const UserId& previously_active_id,
                                          const UserId& active_id) {
 }
 
 void WindowServer::OnUserIdAdded(const UserId& id) {
   activity_monitor_map_[id] = base::MakeUnique<UserActivityMonitor>(nullptr);
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace ui