Implement service-side surface synchronization

cc/surfaces/surface_manager.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 "cc/surfaces/surface_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 62 matching lines @@
 }
 
 #if DCHECK_IS_ON()
 std::string SurfaceManager::SurfaceReferencesToString() {
   std::stringstream str;
   SurfaceReferencesToStringImpl(root_surface_id_, "", &str);
   return str.str();
 }
 #endif
 
+void SurfaceManager::SetDependencyTracker(
+    std::unique_ptr<SurfaceDependencyTracker> dependency_tracker) {
+  dependency_tracker_ = std::move(dependency_tracker);
+}
+
+void SurfaceManager::RequestSurfaceResolution(Surface* pending_surface) {
+  if (dependency_tracker_)
+    dependency_tracker_->RequestSurfaceResolution(pending_surface);
+}
+
 void SurfaceManager::RegisterSurface(Surface* surface) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface);
   DCHECK(!surface_map_.count(surface->surface_id()));
   surface_map_[surface->surface_id()] = surface;
 }
 
 void SurfaceManager::DeregisterSurface(const SurfaceId& surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SurfaceMap::iterator it = surface_map_.find(surface_id);
@@ skipping 48 matching lines @@
   // Check some conditions that should never happen. We don't want to crash on
   // bad input from a compromised client so just return early.
   if (parent_id.frame_sink_id() == child_id.frame_sink_id()) {
     DLOG(ERROR) << "Cannot add self reference from " << parent_id << " to "
                 << child_id;
     return;
   }
 
   // We trust that |parent_id| either exists or is about to exist, since is not
   // sent over IPC. We don't trust |child_id|, since it is sent over IPC.
-  if (surface_map_.count(child_id) == 0) {
-    DLOG(ERROR) << "No surface in map for " << child_id.ToString();
-    return;
-  }
+  // if (surface_map_.count(child_id) == 0) {

[vmpstr, 2017/02/07 22:46:20]

<_<

[Fady Samuel, 2017/02/08 00:52:50]

Heh fixed in a later patchset. Sorry about that.

+  //  DLOG(ERROR) << "No surface in map for " << child_id.ToString();
+  //  return;
+  //}
 
   // There could be a temporary reference to |child_id| which we should now
   // remove because a real reference is being added to it. To find out whether
   // or not a temporary reference exists, we need to first look up the
   // FrameSinkId of |child_id| in |temp_references_|, which returns a vector of
   // LocalSurfaceIds, and then search for the LocalSurfaceId of |child_id| in
   // the
   // said vector. If there is no temporary reference, we can immediately add the
   // reference from |parent_id| and return.
   auto refs_iter = temp_references_.find(child_id.frame_sink_id());
@@ skipping 45 matching lines @@
   // Check if we have the reference that is requested to be removed. We don't
   // want to crash on bad input from a compromised client so just return early.
   if (parent_to_child_refs_.count(parent_id) == 0 ||
       parent_to_child_refs_[parent_id].count(child_id) == 0) {
     DLOG(ERROR) << "No reference from " << parent_id.ToString() << " to "
                 << child_id.ToString();
     return;
   }
 
   RemoveSurfaceReferenceImpl(parent_id, child_id);
+  GarbageCollectSurfaces();
 }
 
 void SurfaceManager::AddSurfaceReferences(
     const std::vector<SurfaceReference>& references) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (const auto& reference : references)
     AddSurfaceReference(reference.parent_id(), reference.child_id());
 }
 
@@ skipping 360 matching lines @@
                                                    std::string indent,
                                                    std::stringstream* str) {
   *str << indent;
 
   // Print the current line for |surface_id|.
   Surface* surface = GetSurfaceForId(surface_id);
   if (surface) {
     *str << surface->surface_id().ToString();
     *str << (surface->destroyed() ? " destroyed " : " live ");
 
+    if (surface->GetPendingFrame().has_value()) {
+      // This provides the surface size from the root render pass.
+      const CompositorFrame& frame = surface->GetPendingFrame().value();
+      *str << "pending "
+           << frame.render_pass_list.back()->output_rect.size().ToString()
+           << " ";
+    }
+
     if (surface->HasFrame()) {
       // This provides the surface size from the root render pass.
       const CompositorFrame& frame = surface->GetEligibleFrame();
-      *str << frame.render_pass_list.back()->output_rect.size().ToString();
+      *str << "active "
+           << frame.render_pass_list.back()->output_rect.size().ToString();
     }
   } else {
     *str << surface_id;
   }
   *str << "\n";
 
   // If the current surface has references to children, sort children and print
   // references for each child.
   auto iter = parent_to_child_refs_.find(surface_id);
   if (iter != parent_to_child_refs_.end()) {
     std::vector<SurfaceId> children(iter->second.begin(), iter->second.end());
     std::sort(children.begin(), children.end());
 
     for (const SurfaceId& child_id : children)
       SurfaceReferencesToStringImpl(child_id, indent + "  ", str);
   }
 }
 #endif  // DCHECK_IS_ON()
 
 }  // namespace cc