cc: Add SwapPromiseManager and SurfaceSequenceGenerator.

cc/trees/layer_tree_host.h

 // Copyright 2011 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 CC_TREES_LAYER_TREE_HOST_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 #include "cc/input/input_handler.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_list_iterator.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/swap_promise.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/scoped_ui_resource.h"
-#include "cc/surfaces/surface_sequence.h"
+#include "cc/surfaces/surface_sequence_generator.h"
 #include "cc/trees/compositor_mode.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_interface.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/rect.h"
 
@@ skipping 21 matching lines @@
 class RenderingStatsInstrumentation;
 class ResourceProvider;
 class ResourceUpdateQueue;
 class SharedBitmapManager;
 class TaskGraphRunner;
 class TopControlsManager;
 class UIResourceRequest;
 struct PendingPageScaleAnimation;
 struct RenderingStats;
 struct ScrollAndScaleSet;
+class SwapPromiseManager;
 
 namespace proto {
 class LayerTreeHost;
 }
 
 // This class is being refactored to an interface, see LayerTreeHostInterface,
 // which is the API for the cc embedder. When adding new code to this class,
 // consider the following:
 // 1) If its state/data that gets pushed to the LayerTreeImpl during commit, add
 //    it to the LayerTree.
@@ skipping 49 matching lines @@
       InitParams* params);
 
   ~LayerTreeHost() override;
 
   // LayerTreeHostInterface implementation.
   int GetId() const override;
   int SourceFrameNumber() const override;
   LayerTree* GetLayerTree() override;
   const LayerTree* GetLayerTree() const override;
   TaskRunnerProvider* GetTaskRunnerProvider() const override;
+  SwapPromiseManager* GetSwapPromiseManager() const override;
   const LayerTreeSettings& GetSettings() const override;
-  void SetSurfaceClientId(uint32_t client_id) override;
+  SurfaceSequenceGenerator* GetSurfaceSequenceGenerator() override;
   void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator) override;
-  void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise) override;
   void SetHasGpuRasterizationTrigger(bool has_trigger) override;
   void SetVisible(bool visible) override;
   bool IsVisible() const override;
   void SetOutputSurface(std::unique_ptr<OutputSurface> output_surface) override;
   std::unique_ptr<OutputSurface> ReleaseOutputSurface() override;
   void SetNeedsAnimate() override;
   void SetNeedsUpdateLayers() override;
   void SetNeedsCommit() override;
   bool BeginMainFrameRequested() const override;
   bool CommitRequested() const override;
@@ skipping 10 matching lines @@
   const base::WeakPtr<InputHandler>& GetInputHandler() const override;
   void DidStopFlinging() override;
   void SetDebugState(const LayerTreeDebugState& debug_state) override;
   const LayerTreeDebugState& GetDebugState() const override;
   int ScheduleMicroBenchmark(
       const std::string& benchmark_name,
       std::unique_ptr<base::Value> value,
       const MicroBenchmark::DoneCallback& callback) override;
   bool SendMessageToMicroBenchmark(int id,
                                    std::unique_ptr<base::Value> value) override;
-  void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) override;
-  void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) override;
 
   // LayerTreeHost interface to Proxy.
   void WillBeginMainFrame();
   void DidBeginMainFrame();
   void BeginMainFrame(const BeginFrameArgs& args);
   void BeginMainFrameNotExpectedSoon();
   void AnimateLayers(base::TimeTicks monotonic_frame_begin_time);
   void RequestMainFrameUpdate();
   void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl);
   void WillCommit();
@@ skipping 41 matching lines @@
   // resource, which is always positive.
   virtual UIResourceId CreateUIResource(UIResourceClient* client);
   // Deletes a UI resource.  May safely be called more than once.
   virtual void DeleteUIResource(UIResourceId id);
   // Put the recreation of all UI resources into the resource queue after they
   // were evicted on the impl thread.
   void RecreateUIResources();
 
   virtual gfx::Size GetUIResourceSize(UIResourceId id) const;
 
-  void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
-  std::vector<std::unique_ptr<SwapPromise>> TakeSwapPromises();
-
-  size_t num_queued_swap_promises() const { return swap_promise_list_.size(); }
-
-  SurfaceSequence CreateSurfaceSequence();
-
   // Serializes the parts of this LayerTreeHost that is needed for a commit to a
   // protobuf message. Not all members are serialized as they are not helpful
   // for remote usage.
   // The |swap_promise_list_| is transferred to the serializer in
   // |swap_promises|.
   void ToProtobufForCommit(
       proto::LayerTreeHost* proto,
       std::vector<std::unique_ptr<SwapPromise>>* swap_promises);
 
   // Deserializes the protobuf into this LayerTreeHost before a commit. The
@@ skipping 98 matching lines @@
   using UIResourceClientMap =
       std::unordered_map<UIResourceId, UIResourceClientData>;
   UIResourceClientMap ui_resource_client_map_;
   int next_ui_resource_id_;
 
   using UIResourceRequestQueue = std::vector<UIResourceRequest>;
   UIResourceRequestQueue ui_resource_request_queue_;
 
   void CalculateLCDTextMetricsCallback(Layer* layer);
 
-  void NotifySwapPromiseMonitorsOfSetNeedsCommit();
-
   void SetPropertyTreesNeedRebuild();
 
   const CompositorMode compositor_mode_;
 
   LayerTreeHostClient* client_;
   std::unique_ptr<Proxy> proxy_;
   std::unique_ptr<TaskRunnerProvider> task_runner_provider_;
 
   int source_frame_number_;
   std::unique_ptr<RenderingStatsInstrumentation>
       rendering_stats_instrumentation_;
 
+  std::unique_ptr<SwapPromiseManager> swap_promise_manager_;
+
   // |current_output_surface_| can't be updated until we've successfully
   // initialized a new output surface. |new_output_surface_| contains the
   // new output surface that is currently being initialized. If initialization
   // is successful then |new_output_surface_| replaces
   // |current_output_surface_|.
   std::unique_ptr<OutputSurface> new_output_surface_;
   std::unique_ptr<OutputSurface> current_output_surface_;
 
   const LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
@@ skipping 12 matching lines @@
   bool next_commit_forces_redraw_;
 
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
 
   ImageSerializationProcessor* image_serialization_processor_;
   std::unique_ptr<EnginePictureCache> engine_picture_cache_;
   std::unique_ptr<ClientPictureCache> client_picture_cache_;
 
-  std::vector<std::unique_ptr<SwapPromise>> swap_promise_list_;
-  std::set<SwapPromiseMonitor*> swap_promise_monitor_;
-
-  uint32_t surface_client_id_;
-  uint32_t next_surface_sequence_;
+  SurfaceSequenceGenerator surface_sequence_generator_;
   uint32_t num_consecutive_frames_suitable_for_gpu_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_