Mozart: Improve tracing and backpressure.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
 #include "mojo/skia/type_converters.h"
 #include "services/gfx/compositor/backend/gpu_output.h"
 #include "services/gfx/compositor/graph/snapshot.h"
 #include "services/gfx/compositor/render/render_frame.h"
 #include "services/gfx/compositor/renderer_impl.h"
 #include "services/gfx/compositor/scene_impl.h"
 
 namespace compositor {
 namespace {
@@ skipping 319 matching lines @@
                  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;
 }
 
+void CompositorEngine::ComposeRenderer(
+    RendererState* renderer_state,
+    const mojo::gfx::composition::FrameInfo& frame_info) {
+  DCHECK(IsRendererStateRegisteredDebug(renderer_state));
+  DVLOG(2) << "ComposeRenderer: renderer_state=" << renderer_state;
+
+  TRACE_EVENT1("gfx", "CompositorEngine::ComposeRenderer", "renderer",
+               renderer_state->FormattedLabel());
+
+  int64_t composition_time = MojoGetTimeTicksNow();
+  PresentRenderer(renderer_state, frame_info.presentation_time);
+  SnapshotRenderer(renderer_state);
+  PaintRenderer(renderer_state, frame_info, composition_time);
+}
+
 void CompositorEngine::PresentRenderer(RendererState* renderer_state,
                                        int64_t presentation_time) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DVLOG(2) << "PresentRenderer: renderer_state=" << renderer_state;
 
+  TRACE_EVENT1("gfx", "CompositorEngine::PresentRenderer", "renderer",
+               renderer_state->FormattedLabel());
+
   // TODO(jeffbrown): Be more selective and do this work only for scenes
   // associated with the renderer that actually have pending updates.
   std::vector<SceneState*> dead_scenes;
   for (auto& pair : scenes_by_token_) {
     SceneState* scene_state = pair.second;
     SceneDef::Disposition disposition =
         PresentScene(scene_state, presentation_time);
     if (disposition == SceneDef::Disposition::kFailed)
       dead_scenes.push_back(scene_state);
   }
   for (SceneState* scene_state : dead_scenes)
     DestroyScene(scene_state);
 }
 
-void CompositorEngine::SnapshotRenderer(
-    RendererState* renderer_state,
-    const mojo::gfx::composition::FrameInfo& frame_info) {
+void CompositorEngine::SnapshotRenderer(RendererState* renderer_state) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DVLOG(2) << "SnapshotRenderer: renderer_state=" << renderer_state;
 
+  TRACE_EVENT1("gfx", "CompositorEngine::SnapshotRenderer", "renderer",
+               renderer_state->FormattedLabel());
+
   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:" << std::endl
                << block_log.str();
     } else if (!block_log.str().empty()) {
       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 {
-    SkIRect viewport = renderer_state->root_scene_viewport().To<SkIRect>();
-    if (!viewport.isEmpty()) {
-      renderer_state->output()->SubmitFrame(
-          new RenderFrame(viewport, 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;
   }
 
   renderer_state->SetSnapshot(
       universe_.SnapshotScene(renderer_state->root_scene()->scene_token(),
                               renderer_state->root_scene_version(), block_log));
 }
 
+void CompositorEngine::PaintRenderer(
+    RendererState* renderer_state,
+    const mojo::gfx::composition::FrameInfo& frame_info,
+    int64_t composition_time) {
+  DCHECK(IsRendererStateRegisteredDebug(renderer_state));
+  DVLOG(2) << "PaintRenderer: renderer_state=" << renderer_state;
+
+  TRACE_EVENT1("gfx", "CompositorEngine::PaintRenderer", "renderer",
+               renderer_state->FormattedLabel());
+
+  RenderFrame::Metadata frame_metadata(frame_info, composition_time);
+
+  if (renderer_state->visible_snapshot()) {

[mikejurka, 2016/05/19 23:26:19]

could you add a comment explaining this if/else branch? does it have to do with
whether something is ready to be painted or not?

[jeffbrown, 2016/05/20 01:09:48]

ok

+    DCHECK(!renderer_state->visible_snapshot()->is_blocked());
+    renderer_state->output()->SubmitFrame(
+        renderer_state->visible_snapshot()->Paint(
+            frame_metadata, renderer_state->root_scene_viewport()));
+  } else {
+    SkIRect viewport = renderer_state->root_scene_viewport().To<SkIRect>();
+    if (!viewport.isEmpty()) {
+      renderer_state->output()->SubmitFrame(
+          new RenderFrame(frame_metadata, viewport));
+    }
+  }
+}
+
 void CompositorEngine::ScheduleFrameForRenderer(
     RendererState* renderer_state,
     Scheduler::SchedulingMode scheduling_mode) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   renderer_state->output()->GetScheduler()->ScheduleFrame(scheduling_mode);
 }
 
 void CompositorEngine::OnOutputError(
     const base::WeakPtr<RendererState>& renderer_state_weak) {
   RendererState* renderer_state = renderer_state_weak.get();
@@ skipping 23 matching lines @@
 }
 
 void CompositorEngine::OnOutputSnapshotRequest(
     const base::WeakPtr<RendererState>& renderer_state_weak,
     const mojo::gfx::composition::FrameInfo& frame_info) {
   RendererState* renderer_state = renderer_state_weak.get();
   if (!renderer_state)
     return;
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
 
-  PresentRenderer(renderer_state, frame_info.presentation_time);
-  SnapshotRenderer(renderer_state, frame_info);
+  ComposeRenderer(renderer_state, frame_info);
 }
 
 void CompositorEngine::OnPresentScene(
     const base::WeakPtr<SceneState>& scene_state_weak,
     int64_t presentation_time) {
   SceneState* scene_state = scene_state_weak.get();
   if (!scene_state)
     return;
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
 
   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