Mozart: Reduce pipeline depth and unify frame queue.

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>
@@ skipping 16 matching lines @@
  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:
-  struct FrameData : public base::RefCountedThreadSafe<FrameData> {
+  struct FrameData {
     FrameData(const scoped_refptr<RenderFrame>& frame, int64_t submit_time);
+    ~FrameData();
 
-    void Recycle();
+    void ClearDrawState();
 
     const scoped_refptr<RenderFrame> frame;
     const int64_t submit_time;

[mikejurka, 2016/05/25 21:11:46]

i would be a bit more descriptive, call this draw_submitted_time

[jeffbrown, 2016/05/25 23:45:44]

I think that might get confused with draw_time.  submit_time is actually set in
SubmitFrame which I think makes sense.

-    bool drawn = false;     // set when DrawFrame is called
-    int64_t draw_time = 0;  // 0 if not drawn
-    int64_t wait_time = 0;  // 0 if not drawn
+    bool drawn = false;     // set when |DrawFrame| is called
+    bool finished = false;  // set when drawing is finished

[mikejurka, 2016/05/25 21:11:46]

why not call these draw_started and draw_finished?

also, as mentioned in the other file, consider having a pinned_for_draw
variable.

[jeffbrown, 2016/05/25 23:45:44]

Sure, draw_started and draw_finished makes sense.

+    int64_t draw_time = 0;  // time when drawing began

[mikejurka, 2016/05/25 21:11:46]

similarly, why not call this draw_start_time

[jeffbrown, 2016/05/25 23:45:44]

Ok.

+    int64_t wait_time = 0;  // time when awaiting for finish began

[mikejurka, 2016/05/25 21:11:46]

wait_time implies a timespan rather than an absolute time. what about something
like rasterizer_done_time or draw_end_time (avoiding the word "finished" because
you have specific semantics for that ie thats when your callback fires).

[jeffbrown, 2016/05/25 23:45:43]

draw_issued_time?

 
    private:
-    friend class base::RefCountedThreadSafe<FrameData>;
-
-    ~FrameData();
-
     DISALLOW_COPY_AND_ASSIGN(FrameData);
   };
 
   // |GpuRasterizer::Callbacks|:
   void OnRasterizerReady(int64_t vsync_timebase,
                          int64_t vsync_interval) override;
   void OnRasterizerSuspended() override;
   void OnRasterizerFinishedDraw(bool presented) override;
   void OnRasterizerError() override;
 
@@ skipping 16 matching lines @@
   // 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;
+    // Queue of frames.
+    //
+    // The head of this queue consists of up to |pipeline_depth| frames
+    // which are drawn and awaiting finish.  These frames are popped off
+    // the queue when finished unless the queue would become empty (such
+    // that we always retain the current frame as the tail).
+    //
+    // The tail of this queue is a single frame which is either drawn or
+    // finished and represents the current (most recently submitted)
+    // content.
+    //
+    // The queue is only ever empty until the first frame is submitted.
+    // Subsequently, it always contains at least one frame.
+    std::queue<std::unique_ptr<FrameData>> frames;
 
     // 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_