blimp: Use SwapPromises for readback API.

blimp/client/core/compositor/blimp_compositor.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 BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
 #define BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 18 matching lines @@
 
 namespace cc {
 class InputHandler;
 
 namespace proto {
 class CompositorMessage;
 }  // namespace proto
 
 class CompositorStateDeserializer;
 class ContextProvider;
+class CopyOutputRequest;
 class Layer;
 class LayerTreeHost;
 class LayerTreeSettings;
 class LocalFrameid;
 class Surface;
 class SurfaceFactory;
 class SurfaceIdAllocator;
 }  // namespace cc
 
 namespace blimp {
@@ skipping 34 matching lines @@
                         public cc::CompositorStateDeserializerClient {
  public:
   BlimpCompositor(BlimpCompositorDependencies* compositor_dependencies,
                   BlimpCompositorClient* client,
                   bool use_threaded_layer_tree_host);
 
   ~BlimpCompositor() override;
 
   virtual void SetVisible(bool visible);
 
-  // Notifies |callback| when all pending commits have been drawn to the screen.
-  // If this compositor is destroyed or becomes hidden |callback| will be
-  // notified.
-  void NotifyWhenDonePendingCommits(base::Closure callback);
+  // Requests a copy of the compositor frame.
+  // Setting |flush_pending_update| to true ensures that if a frame update on
+  // the main thread is pending, then it is drawn before copying from the
+  // surface.
+  void RequestCopyOfOutput(std::unique_ptr<cc::CopyOutputRequest> copy_request,
+                           bool flush_pending_update);
 
   // Called to forward the compositor message from the remote server
   // LayerTreeHost of the render widget for this compositor.
   // virtual for testing.
   virtual void OnCompositorMessageReceived(
       std::unique_ptr<cc::proto::CompositorMessage> message);
 
   scoped_refptr<cc::Layer> layer() const { return layer_; }
 
   // Returns a reference to the InputHandler used to respond to input events on
   // the compositor thread.
   const base::WeakPtr<cc::InputHandler>& GetInputHandler();
 
  private:
   friend class BlimpCompositorForTesting;
+  class FrameTrackingSwapPromise;
 
   // LayerTreeHostClient implementation.
   void WillBeginMainFrame() override {}
   void DidBeginMainFrame() override {}
   void BeginMainFrame(const cc::BeginFrameArgs& args) override {}
   void BeginMainFrameNotExpectedSoon() override {}
   void UpdateLayerTreeHost() override;
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
@@ skipping 47 matching lines @@
   void DestroyDelegatedContent();
 
   // Helper method to build the internal CC LayerTreeHost instance from
   // |message|.
   void CreateLayerTreeHost();
 
   // Helper method to destroy the internal CC LayerTreeHost instance and all its
   // associated state.
   void DestroyLayerTreeHost();
 
-  // Updates |pending_commit_trackers_|, decrementing the count and, if 0,
-  // notifying the callback.  If |flush| is true, flushes all entries regardless
-  // of the count.
-  void CheckPendingCommitCounts(bool flush);
-
   // Acks a submitted CompositorFrame when it has been processed and another
   // frame should be started.
   void SubmitCompositorFrameAck();
 
   // Called when the local copy of the layer with |engine_layer_id| on the
   // engine was scrolled on the compositor thread.
   void LayerScrolled(int engine_layer_id);
 
   // Set to true if we are using a LayerTreeHostInProcess to process frame
   // updates from the engine.
   const bool use_threaded_layer_tree_host_;
 
+  void MakeCopyRequestOnNextSwap(
+      std::unique_ptr<cc::CopyOutputRequest> copy_request);
+
+  void RequestCopyOfOutputDeprecated(
+      std::unique_ptr<cc::CopyOutputRequest> copy_request);
+
   BlimpCompositorClient* client_;
 
   BlimpCompositorDependencies* compositor_dependencies_;
 
   cc::FrameSinkId frame_sink_id_;
 
   std::unique_ptr<cc::LayerTreeHost> host_;
 
   // The SurfaceFactory is bound to the lifetime of the |proxy_client_|. When
   // detached, the surface factory will be destroyed.
@@ skipping 11 matching lines @@
 
   // Surfaces related stuff and layer which holds the delegated content from the
   // compositor.
   std::unique_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
   scoped_refptr<cc::Layer> layer_;
 
   // To be notified of any incoming compositor protos that are specifically sent
   // to |render_widget_id_|.
   cc::RemoteProtoChannel::ProtoReceiver* remote_proto_channel_receiver_;
 
+  std::vector<std::unique_ptr<cc::CopyOutputRequest>>
+      copy_requests_for_next_swap_;
+
   // The number of times a START_COMMIT proto has been received but a call to
   // DidCommitAndDrawFrame hasn't been seen.  This should track the number of
   // outstanding commits.
   size_t outstanding_commits_;
 
-  // When NotifyWhenDonePendingCommitsis called |outstanding_commits_| is copied
-  // along with the |callback| into this vector.  Each time
-  // DidCommitAndDrawFrame is called these entries get decremented.  If they hit
-  // 0 the callback is triggered.
-  std::vector<std::pair<size_t, base::Closure>> pending_commit_trackers_;
+  // When RequestCopyOfOutput is called with a request to flush any pending
+  // updates, |outstanding_commits_| is copied along with the |copy_request|
+  // into this vector. Each time DidCommitAndDrawFrame is called these entries
+  // get decremented.  If they hit 0 the copy request is queued for the current
+  // |local_frame_id_|.
+  std::vector<std::pair<size_t, std::unique_ptr<cc::CopyOutputRequest>>>
+      pending_commit_trackers_;
 
   // Stores a frame update received from the engine, when a threaded
   // LayerTreeHost is used. There can only be a single frame in flight at any
   // point.
   std::unique_ptr<cc::proto::CompositorMessage> pending_frame_update_;
 
   // Used with a threaded LayerTreeHost to deserialize proto updates from the
   // engine into the LayerTree.
   std::unique_ptr<cc::CompositorStateDeserializer>
       compositor_state_deserializer_;
 
   base::WeakPtrFactory<BlimpCompositor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace client
 }  // namespace blimp
 
 #endif  // BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_