Mozart: Improve tracing and backpressure.

services/gfx/compositor/backend/gpu_output.h

 // 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.
 
 #ifndef SERVICES_GFX_COMPOSITOR_BACKEND_GPU_OUTPUT_H_
 #define SERVICES_GFX_COMPOSITOR_BACKEND_GPU_OUTPUT_H_
 
 #include <memory>
 #include <mutex>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/task_runner.h"
 #include "base/threading/thread.h"
 #include "mojo/services/gpu/interfaces/context_provider.mojom.h"
+#include "services/gfx/compositor/backend/gpu_rasterizer.h"
 #include "services/gfx/compositor/backend/output.h"
 #include "services/gfx/compositor/backend/vsync_scheduler.h"
 
 namespace compositor {
 
-class GpuRasterizer;
-
 // Renderer backed by a ContextProvider.
-class GpuOutput : public Output {
+class GpuOutput : public Output, private GpuRasterizer::Callbacks {
  public:
   GpuOutput(mojo::InterfaceHandle<mojo::ContextProvider> context_provider,
             const SchedulerCallbacks& scheduler_callbacks,
             const base::Closure& error_callback);
   ~GpuOutput() override;
 
   Scheduler* GetScheduler() override;
   void SubmitFrame(const scoped_refptr<RenderFrame>& frame) override;
 
  private:
-  // Wrapper around state which is made available to the rasterizer thread.
-  class RasterizerDelegate {
-   public:
-    RasterizerDelegate();
-    ~RasterizerDelegate();
+  struct FrameData : public base::RefCountedThreadSafe<FrameData> {
+    FrameData(const scoped_refptr<RenderFrame>& frame, int64_t submit_time);
 
-    void PostInitialize(
-        mojo::InterfaceHandle<mojo::ContextProvider> context_provider,
-        const scoped_refptr<VsyncScheduler>& scheduler,
-        const scoped_refptr<base::TaskRunner>& task_runner,
-        const base::Closure& error_callback);
+    void Recycle();
 
-    void PostDestroy(scoped_ptr<RasterizerDelegate> self);
-
-    void PostFrame(const scoped_refptr<RenderFrame>& frame);
+    const scoped_refptr<RenderFrame> frame;
+    const int64_t submit_time;
+    bool drawn = false;     // set when DrawFrame is called

[mikejurka, 2016/05/20 01:49:23]

this works. but it wasn't my intention to force you to add a boolean, just to
add comments when you checked draw_time in a boolean expression. 

[jeffbrown, 2016/05/20 19:31:35]

It's fine.  Technically this is better anyhow since a zero timestamp could
hypothetically occur though in general the time ticks are anchored to 0 at boot
time.

+    int64_t draw_time = 0;  // 0 if not drawn
+    int64_t wait_time = 0;  // 0 if not drawn
 
    private:
-    void PostSubmit();
+    friend class base::RefCountedThreadSafe<FrameData>;
 
-    // Called on rasterizer thread.
-    void InitializeTask(
-        mojo::InterfaceHandle<mojo::ContextProvider> context_provider,
-        const scoped_refptr<VsyncScheduler>& scheduler,
-        const scoped_refptr<base::TaskRunner>& task_runner,
-        const base::Closure& error_callback);
+    ~FrameData();
 
-    // Called on rasterizer thread.
-    void SubmitTask();
-
-    // Called on rasterizer thread.
-    void OnFrameSubmitted(int64_t frame_time,
-                          int64_t presentation_time,
-                          int64_t submit_time,
-                          bool presented);
-
-    std::unique_ptr<base::Thread> thread_;
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-    std::unique_ptr<GpuRasterizer> rasterizer_;
-
-    std::mutex mutex_;
-    std::queue<scoped_refptr<RenderFrame>> frames_;  // guarded by |mutex_|
-
-    DISALLOW_COPY_AND_ASSIGN(RasterizerDelegate);
+    DISALLOW_COPY_AND_ASSIGN(FrameData);
   };
 
-  scoped_refptr<VsyncScheduler> scheduler_;
-  scoped_ptr<RasterizerDelegate> rasterizer_delegate_;  // can't use unique_ptr
-                                                        // here due to
-                                                        // base::Bind (sadness)
+  // |GpuRasterizer::Callbacks|:
+  void OnRasterizerReady(int64_t vsync_timebase,
+                         int64_t vsync_interval) override;
+  void OnRasterizerSuspended() override;
+  void OnRasterizerFinishedDraw(bool presented) override;
+  void OnRasterizerError() override;
+
+  void ScheduleDrawLocked();
+  void OnDraw();
+
+  void InitializeRasterizer(
+      mojo::InterfaceHandle<mojo::ContextProvider> context_provider);
+  void DestroyRasterizer();
+  void PostErrorCallback();
+
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
+  scoped_refptr<VsyncScheduler> vsync_scheduler_;
+  base::Closure error_callback_;
+
+  // Maximum number of frames to hold in the drawing pipeline.
+  // Any more than this and we start dropping them.
+  uint32_t pipeline_depth_;
+
+  // The rasterizer itself runs on its own thread.
+  std::unique_ptr<base::Thread> rasterizer_thread_;
+  scoped_refptr<base::SingleThreadTaskRunner> rasterizer_task_runner_;
+  base::WaitableEvent rasterizer_initialized_;
+  std::unique_ptr<GpuRasterizer> rasterizer_;
+
+  // Holds state shared between the compositor and rasterizer threads.
+  struct {
+    std::mutex mutex;  // guards all shared state
+
+    // The most recently submitted frame.
+    // Only null until the first frame has been submitted.
+    scoped_refptr<FrameData> current_frame_data;
+
+    // Frames drawn and awaiting completion by the rasterizer.
+    std::queue<scoped_refptr<FrameData>> drawn_frames_awaiting_finish;
+
+    // Set to true when the rasterizer is ready to draw.
+    bool rasterizer_ready = false;
+
+    // Set to true when a request to draw has been scheduled.
+    bool draw_scheduled = false;
+  } shared_state_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuOutput);
 };
 
 }  // namespace compositor
 
 #endif  // SERVICES_GFX_COMPOSITOR_BACKEND_GPU_OUTPUT_H_