Mozart: Generalize frame scheduling.

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 197 matching lines @@
   } else {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&CompositorEngine::OnPresentScene,
                               weak_factory_.GetWeakPtr(),
                               scene_state->GetWeakPtr(), presentation_time),
         base::TimeDelta::FromMicroseconds(presentation_time - now));
   }
 }
 
 void CompositorEngine::ScheduleFrame(SceneState* scene_state,
-                                     const SceneFrameCallback& callback) {
+                                     const FrameCallback& callback) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
+  DVLOG(1) << "ScheduleFrame: scene=" << scene_state;
 
-  scene_state->AddSceneFrameCallback(callback);
+  if (!scene_state->frame_dispatcher().AddCallback(callback))
+    return;
 
   // TODO(jeffbrown): Be more selective and do this work only for scenes
   // which are strongly associated with the renderer so it doesn't receive
   // conflicting timing signals coming from multiple renderers.
   for (auto& renderer : renderers_) {
     ScheduleFrameForRenderer(renderer,
                              Scheduler::SchedulingMode::kUpdateAndSnapshot);
   }
 }
 
@@ skipping 37 matching lines @@
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DVLOG(1) << "ClearRootScene: renderer=" << renderer_state;
 
   // Update the root.
   if (renderer_state->ClearRootScene()) {
     ScheduleFrameForRenderer(renderer_state,
                              Scheduler::SchedulingMode::kSnapshot);
   }
 }
 
+void CompositorEngine::ScheduleFrame(RendererState* renderer_state,
+                                     const FrameCallback& callback) {
+  DCHECK(IsRendererStateRegisteredDebug(renderer_state));
+  DVLOG(1) << "ScheduleFrame: renderer=" << renderer_state;
+
+  if (!renderer_state->frame_dispatcher().AddCallback(callback))
+    return;
+
+  ScheduleFrameForRenderer(renderer_state,
+                           Scheduler::SchedulingMode::kUpdateAndSnapshot);
+}
+
 void CompositorEngine::HitTest(
     RendererState* renderer_state,
     mojo::PointFPtr point,
     const mojo::gfx::composition::HitTester::HitTestCallback& callback) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DCHECK(point);
   DVLOG(1) << "HitTest: renderer=" << renderer_state << ", point=" << point;
 
   auto result = mojo::gfx::composition::HitTestResult::New();
 
@@ skipping 185 matching lines @@
 }
 
 void CompositorEngine::OnOutputUpdateRequest(
     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));
 
+  renderer_state->frame_dispatcher().DispatchCallbacks(frame_info);
+
   // TODO(jeffbrown): Be more selective and do this work only for scenes
   // associated with the renderer.
   for (auto& pair : scenes_by_token_) {
-    pair.second->DispatchSceneFrameCallbacks(frame_info);
+    pair.second->frame_dispatcher().DispatchCallbacks(frame_info);
   }
 }
 
 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));
@@ skipping 11 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