Mozart: Make Snapshot immutable.

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 86 matching lines @@
   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);
 
   // Create the state and bind implementation to it.
   RendererState* renderer_state =
       new RendererState(renderer_id, SanitizeLabel(label));
   RendererImpl* renderer_impl =
       new RendererImpl(this, renderer_state, renderer_request.Pass());
   renderer_state->set_renderer_impl(renderer_impl);
   renderer_impl->set_connection_error_handler(
       base::Bind(&CompositorEngine::OnRendererConnectionError,
                  base::Unretained(this), renderer_state));
@@ skipping 185 matching lines @@
 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->snapshot() &&
-        renderer->snapshot()->InvalidateScene(scene_state->scene_def())) {
+    if (renderer->current_snapshot() &&
+        renderer->current_snapshot()->HasDependency(scene_state->scene_def())) {
       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;
@@ skipping 34 matching lines @@
 
 void CompositorEngine::SnapshotRenderer(
     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, frame_info, &block_log);
-    if (!renderer_state->frame()) {
+    if (!renderer_state->current_snapshot() ||
+        renderer_state->current_snapshot()->is_blocked()) {
       DVLOG(2) << "Rendering completely blocked: " << block_log.str();
     } else if (!block_log.str().empty()) {
       DVLOG(2) << "Rendering partially blocked: " << block_log.str();
     } else {
       DVLOG(2) << "Rendering unblocked";
     }
   } else {
     SnapshotRendererInner(renderer_state, frame_info, nullptr);
   }
+
+  if (renderer_state->current_snapshot() &&
+      !renderer_state->current_snapshot()->is_blocked()) {
+    renderer_state->output()->SubmitFrame(
+        renderer_state->current_snapshot()->CreateFrame(
+            renderer_state->root_scene_viewport(), frame_info));
+  }
 }
 
 void CompositorEngine::SnapshotRendererInner(
     RendererState* renderer_state,
     const mojo::gfx::composition::FrameInfo& frame_info,
     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(),
-                    renderer_state->root_scene_viewport(), frame_info));
-
-  if (renderer_state->frame())
-    renderer_state->output()->SubmitFrame(renderer_state->frame());
+      builder.Build(renderer_state->root_scene()->scene_def()));
 }
 
 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