Mozart: Ensure time always runs forward.

services/gfx/compositor/compositor_engine.cc

 // Copyright 2015 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/gfx/compositor/compositor_engine.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 37 matching lines @@
       new SceneState(scene_token.Pass(), SanitizeLabel(label));
   SceneImpl* scene_impl =
       new SceneImpl(this, scene_state, scene_request.Pass());
   scene_state->set_scene_impl(scene_impl);
   base::Closure error_handler =
       base::Bind(&CompositorEngine::OnSceneConnectionError,
                  base::Unretained(this), scene_state);
   scene_impl->set_connection_error_handler(error_handler);
 
   // Add to registry.
-  scenes_by_token_.insert({scene_state->scene_token()->value, scene_state});
+  scenes_by_token_.emplace(scene_state->scene_token().value, scene_state);
+  universe_.AddScene(scene_state->scene_def()->label());
   DVLOG(1) << "CreateScene: scene=" << scene_state;
-  return scene_state->scene_token()->Clone();
+  return scene_state->scene_token().Clone();
 }
 
 void CompositorEngine::OnSceneConnectionError(SceneState* scene_state) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(1) << "OnSceneConnectionError: scene=" << scene_state;
 
   DestroyScene(scene_state);
 }
 
 void CompositorEngine::DestroyScene(SceneState* scene_state) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(1) << "DestroyScene: scene=" << scene_state;
 
-  // Unlink from other scenes.
+  // Notify other scenes which may depend on this one.
   for (auto& pair : scenes_by_token_) {
     SceneState* other_scene_state = pair.second;
-    other_scene_state->scene_def()->UnlinkReferencedScene(
-        scene_state->scene_def(),
+    other_scene_state->scene_def()->NotifySceneUnavailable(
+        scene_state->scene_token(),
         base::Bind(&CompositorEngine::SendResourceUnavailable,
                    base::Unretained(this),
                    base::Unretained(other_scene_state)));
   }
 
   // Destroy any renderers using this scene.
   for (auto& renderer : renderers_) {
     if (renderer->root_scene() == scene_state) {
       LOG(ERROR) << "Destroying renderer whose root scene has become "
                     "unavailable: renderer="
                  << renderer;
       DestroyRenderer(renderer);
     }
   }
 
-  // Destroy.
+  // Consider all dependent rendering to be invalidated.
+  universe_.RemoveScene(scene_state->scene_token());
   InvalidateScene(scene_state);
 
   // Remove from registry.
-  scenes_by_token_.erase(scene_state->scene_token()->value);
+  scenes_by_token_.erase(scene_state->scene_token().value);
   delete scene_state;
 }
 
 void CompositorEngine::CreateRenderer(
     mojo::InterfaceHandle<mojo::ContextProvider> context_provider,
     mojo::InterfaceRequest<mojo::gfx::composition::Renderer> renderer_request,
     const mojo::String& label) {
   DCHECK(context_provider);
   uint32_t renderer_id = next_renderer_id_++;
   CHECK(renderer_id);
@@ skipping 171 matching lines @@
   auto result = mojo::gfx::composition::HitTestResult::New();
 
   if (renderer_state->visible_snapshot()) {
     DCHECK(!renderer_state->visible_snapshot()->is_blocked());
     renderer_state->visible_snapshot()->HitTest(*point, result.get());
   }
 
   callback.Run(result.Pass());
 }
 
-base::WeakPtr<SceneDef> CompositorEngine::ResolveSceneReference(
+bool CompositorEngine::ResolveSceneReference(
     const mojo::gfx::composition::SceneToken& scene_token) {
-  SceneState* scene_state = FindScene(scene_token.value);
-  return scene_state ? scene_state->scene_def()->GetWeakPtr()
-                     : base::WeakPtr<SceneDef>();
+  return FindScene(scene_token.value) != nullptr;
 }
 
 void CompositorEngine::SendResourceUnavailable(SceneState* scene_state,
                                                uint32_t resource_id) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(2) << "SendResourceUnavailable: resource_id=" << resource_id;
 
   // TODO: Detect ANRs
   if (scene_state->scene_listener()) {
     scene_state->scene_listener()->OnResourceUnavailable(
         resource_id, base::Bind(&base::DoNothing));
   }
 }
 
 SceneState* CompositorEngine::FindScene(uint32_t scene_token) {
   auto it = scenes_by_token_.find(scene_token);
   return it != scenes_by_token_.end() ? it->second : nullptr;
 }
 
 void CompositorEngine::InvalidateScene(SceneState* scene_state) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(2) << "InvalidateScene: scene=" << scene_state;
 
   for (auto& renderer : renderers_) {
     if (renderer->current_snapshot() &&
-        renderer->current_snapshot()->HasDependency(scene_state->scene_def())) {
+        renderer->current_snapshot()->HasDependency(
+            scene_state->scene_token())) {
       ScheduleFrameForRenderer(renderer, Scheduler::SchedulingMode::kSnapshot);
     }
   }
 }
 
 SceneDef::Disposition CompositorEngine::PresentScene(
     SceneState* scene_state,
     int64_t presentation_time) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(2) << "PresentScene: scene=" << scene_state;
 
   std::ostringstream errs;
   SceneDef::Disposition disposition = scene_state->scene_def()->Present(
-      presentation_time, base::Bind(&CompositorEngine::ResolveSceneReference,
-                                    base::Unretained(this)),
+      presentation_time, &universe_,
+      base::Bind(&CompositorEngine::ResolveSceneReference,
+                 base::Unretained(this)),
       base::Bind(&CompositorEngine::SendResourceUnavailable,
                  base::Unretained(this), base::Unretained(scene_state)),
       errs);
   if (disposition == SceneDef::Disposition::kFailed) {
     LOG(ERROR) << "Scene published invalid updates: scene=" << scene_state;
     LOG(ERROR) << errs.str();
     // Caller is responsible for destroying the scene.
   }
   return disposition;
 }
@@ skipping 21 matching lines @@
     RendererState* renderer_state,
     const mojo::gfx::composition::FrameInfo& frame_info) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DVLOG(2) << "SnapshotRenderer: renderer_state=" << renderer_state;
 
   if (VLOG_IS_ON(2)) {
     std::ostringstream block_log;
     SnapshotRendererInner(renderer_state, &block_log);
     if (!renderer_state->current_snapshot() ||
         renderer_state->current_snapshot()->is_blocked()) {
-      DVLOG(2) << "Rendering completely blocked: " << block_log.str();
+      DVLOG(2) << "Rendering completely blocked:" << std::endl
+               << block_log.str();
     } else if (!block_log.str().empty()) {
-      DVLOG(2) << "Rendering partially blocked: " << block_log.str();
+      DVLOG(2) << "Rendering partially blocked:" << std::endl
+               << block_log.str();
     } else {
       DVLOG(2) << "Rendering unblocked";
     }
   } else {
     SnapshotRendererInner(renderer_state, nullptr);
   }
 
   if (renderer_state->visible_snapshot()) {
     DCHECK(!renderer_state->visible_snapshot()->is_blocked());
     renderer_state->output()->SubmitFrame(
         renderer_state->visible_snapshot()->CreateFrame(
             renderer_state->root_scene_viewport(), frame_info));
   } else {
     renderer_state->output()->SubmitFrame(new RenderFrame(
         renderer_state->root_scene_viewport().To<SkIRect>(), frame_info));
   }
 }
 
 void CompositorEngine::SnapshotRendererInner(RendererState* renderer_state,
                                              std::ostream* block_log) {
   if (!renderer_state->root_scene()) {
     if (block_log)
       *block_log << "No root scene" << std::endl;
     renderer_state->SetSnapshot(nullptr);
     return;
   }
 
-  SnapshotBuilder builder(block_log);
   renderer_state->SetSnapshot(
-      builder.Build(renderer_state->root_scene()->scene_def()));
+      universe_.SnapshotScene(renderer_state->root_scene()->scene_token(),
+                              renderer_state->root_scene_version(), block_log));
 }
 
 void CompositorEngine::ScheduleFrameForRenderer(
     RendererState* renderer_state,
     Scheduler::SchedulingMode scheduling_mode) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   renderer_state->output()->GetScheduler()->ScheduleFrame(scheduling_mode);
 }
 
 void CompositorEngine::OnOutputError(
@@ skipping 46 matching lines @@
 
   SceneDef::Disposition disposition =
       PresentScene(scene_state, presentation_time);
   if (disposition == SceneDef::Disposition::kFailed)
     DestroyScene(scene_state);
   else if (disposition == SceneDef::Disposition::kSucceeded)
     InvalidateScene(scene_state);
 }
 
 }  // namespace compositor