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 {
+    enum class State {
+      Pending,  // initial state waiting for draw to start
+      Drawing,  // draw has started
+      Finished  // draw has finished
+    };
+
     FrameData(const scoped_refptr<RenderFrame>& frame, int64_t submit_time);
+    ~FrameData();
 
-    void Recycle();
+    void ResetDrawState();
 
     const scoped_refptr<RenderFrame> frame;
     const int64_t submit_time;
-    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
+    State state = State::Pending;
+    int64_t draw_started_time = 0;  // time when drawing began
+    int64_t draw_issued_time = 0;   // time when awaiting for finish began
 
    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_