cc: Add SwapPromiseManager and SurfaceSequenceGenerator.

cc/trees/layer_tree_host.cc

 // 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.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 41 matching lines @@
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree_builder.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/remote_channel_impl.h"
 #include "cc/trees/single_thread_proxy.h"
+#include "cc/trees/swap_promise_manager.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace {
 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
 }
 
 namespace cc {
 namespace {
@@ skipping 136 matching lines @@
 LayerTreeHost::LayerTreeHost(InitParams* params,
                              CompositorMode mode,
                              std::unique_ptr<LayerTree> layer_tree)
     : micro_benchmark_controller_(this),
       layer_tree_(std::move(layer_tree)),
       compositor_mode_(mode),
       ui_resource_manager_(base::MakeUnique<UIResourceManager>()),
       client_(params->client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
+      swap_promise_manager_(base::MakeUnique<SwapPromiseManager>()),
       settings_(*params->settings),
       debug_state_(settings_.initial_debug_state),
       visible_(false),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       did_complete_scale_animation_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
       gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
       task_graph_runner_(params->task_graph_runner),
-      image_serialization_processor_(params->image_serialization_processor),
-      surface_client_id_(0u),
-      next_surface_sequence_(1u) {
+      image_serialization_processor_(params->image_serialization_processor) {
   DCHECK(task_graph_runner_);
   DCHECK(layer_tree_);
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHost::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
@@ skipping 100 matching lines @@
   layer_tree_->animation_host()->SetSupportsScrollAnimations(
       proxy_->SupportsImplScrolling());
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
   // Clear any references into the LayerTreeHost.
   layer_tree_.reset();
 
-  DCHECK(swap_promise_monitor_.empty());
-
-  BreakSwapPromises(SwapPromise::COMMIT_FAILS);
+  swap_promise_manager_.reset();
 
   if (proxy_) {
     DCHECK(task_runner_provider_->IsMainThread());
     proxy_->Stop();
 
     // Proxy must be destroyed before the Task Runner Provider.
     proxy_ = nullptr;
   }
 }
 
@@ skipping 14 matching lines @@
 }
 
 UIResourceManager* LayerTreeHost::GetUIResourceManager() const {
   return ui_resource_manager_.get();
 }
 
 TaskRunnerProvider* LayerTreeHost::GetTaskRunnerProvider() const {
   return task_runner_provider_.get();
 }
 
+SwapPromiseManager* LayerTreeHost::GetSwapPromiseManager() const {
+  return swap_promise_manager_.get();
+}
+
 const LayerTreeSettings& LayerTreeHost::GetSettings() const {
   return settings_;
 }
 
+void LayerTreeHost::SetSurfaceClientId(uint32_t client_id) {
+  surface_sequence_generator_.set_surface_client_id(client_id);
+}
+
+void LayerTreeHost::QueueSwapPromise(
+    std::unique_ptr<SwapPromise> swap_promise) {
+  swap_promise_manager_->QueueSwapPromise(std::move(swap_promise));
+}
+
+SurfaceSequenceGenerator* LayerTreeHost::GetSurfaceSequenceGenerator() {
+  return &surface_sequence_generator_;
+}
+
 void LayerTreeHost::WillBeginMainFrame() {
   devtools_instrumentation::WillBeginMainThreadFrame(GetId(),
                                                      SourceFrameNumber());
   client_->WillBeginMainFrame();
 }
 
 void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
 }
 
@@ skipping 42 matching lines @@
     next_commit_forces_redraw_ = false;
   }
 
   sync_tree->set_source_frame_number(SourceFrameNumber());
 
   if (layer_tree_->needs_full_tree_sync())
     TreeSynchronizer::SynchronizeTrees(layer_tree_->root_layer(), sync_tree);
 
   layer_tree_->PushPropertiesTo(sync_tree);
 
-  sync_tree->PassSwapPromises(std::move(swap_promise_list_));
-  swap_promise_list_.clear();
+  sync_tree->PassSwapPromises(swap_promise_manager_->TakeSwapPromises());
 
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   RecordGpuRasterizationHistogram();
 
   host_impl->SetViewportSize(layer_tree_->device_viewport_size());
   // TODO(senorblanco): Move this to LayerTree::PushPropertiesTo so that it
   // happens before GPU rasterization properties are set, since those trigger an
   // update of GPU rasterization status, which depends on the device scale
@@ skipping 24 matching lines @@
 
   // This must happen after synchronizing property trees and after pushing
   // properties, which updates the clobber_active_value flag.
   sync_tree->UpdatePropertyTreeScrollOffset(layer_tree_->property_trees());
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
   layer_tree_->property_trees()->ResetAllChangeTracking();
 }
 
 void LayerTreeHost::WillCommit() {
-  OnCommitForSwapPromises();
+  swap_promise_manager_->WillCommit();
   client_->WillCommit();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
 }
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
   if (did_complete_scale_animation_) {
@@ skipping 70 matching lines @@
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 DISABLE_CFI_PERF
 void LayerTreeHost::SetNeedsAnimate() {
   proxy_->SetNeedsAnimate();
-  NotifySwapPromiseMonitorsOfSetNeedsCommit();
+  swap_promise_manager_->NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
 DISABLE_CFI_PERF
 void LayerTreeHost::SetNeedsUpdateLayers() {
   proxy_->SetNeedsUpdateLayers();
-  NotifySwapPromiseMonitorsOfSetNeedsCommit();
+  swap_promise_manager_->NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
 void LayerTreeHost::SetNeedsCommit() {
   proxy_->SetNeedsCommit();
-  NotifySwapPromiseMonitorsOfSetNeedsCommit();
+  swap_promise_manager_->NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
 void LayerTreeHost::SetNeedsRedraw() {
   SetNeedsRedrawRect(gfx::Rect(layer_tree_->device_viewport_size()));
 }
 
 void LayerTreeHost::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   proxy_->SetNeedsRedraw(damage_rect);
 }
 
@@ skipping 254 matching lines @@
   SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
   for (auto& swap_promise : info->swap_promises) {
     TRACE_EVENT_WITH_FLOW1("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(swap_promise->TraceId()),
                            TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                            "step", "Main thread scroll update");
-    QueueSwapPromise(std::move(swap_promise));
+    swap_promise_manager_->QueueSwapPromise(std::move(swap_promise));
   }
 
   if (layer_tree_->root_layer()) {
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
       Layer* layer = layer_tree_->LayerById(info->scrolls[i].layer_id);
       if (!layer)
         continue;
       layer->SetScrollOffsetFromImplSide(gfx::ScrollOffsetWithDelta(
           layer->scroll_offset(), info->scrolls[i].scroll_delta));
       SetNeedsUpdateLayers();
@@ skipping 36 matching lines @@
   return micro_benchmark_controller_.ScheduleRun(benchmark_name,
                                                  std::move(value), callback);
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(
     int id,
     std::unique_ptr<base::Value> value) {
   return micro_benchmark_controller_.SendMessage(id, std::move(value));
 }
 
-void LayerTreeHost::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
-  swap_promise_monitor_.insert(monitor);
-}
-
-void LayerTreeHost::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
-  swap_promise_monitor_.erase(monitor);
-}
-
-void LayerTreeHost::NotifySwapPromiseMonitorsOfSetNeedsCommit() {
-  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
-  for (; it != swap_promise_monitor_.end(); it++)
-    (*it)->OnSetNeedsCommitOnMain();
-}
-
-void LayerTreeHost::QueueSwapPromise(
-    std::unique_ptr<SwapPromise> swap_promise) {
-  DCHECK(swap_promise);
-  swap_promise_list_.push_back(std::move(swap_promise));
-}
-
-void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
-  for (const auto& swap_promise : swap_promise_list_)
-    swap_promise->DidNotSwap(reason);
-  swap_promise_list_.clear();
-}
-
-std::vector<std::unique_ptr<SwapPromise>> LayerTreeHost::TakeSwapPromises() {
-  std::vector<std::unique_ptr<SwapPromise>> to_return;
-  to_return.swap(swap_promise_list_);
-  return to_return;
-}
-
-void LayerTreeHost::OnCommitForSwapPromises() {
-  for (const auto& swap_promise : swap_promise_list_)
-    swap_promise->OnCommit();
-}
-
-void LayerTreeHost::SetSurfaceClientId(uint32_t client_id) {
-  surface_client_id_ = client_id;
-}
-
-SurfaceSequence LayerTreeHost::CreateSurfaceSequence() {
-  return SurfaceSequence(surface_client_id_, next_surface_sequence_++);
-}
-
 void LayerTreeHost::SetLayerTreeMutator(
     std::unique_ptr<LayerTreeMutator> mutator) {
   proxy_->SetMutator(std::move(mutator));
 }
 
 bool LayerTreeHost::IsSingleThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::SINGLE_THREADED ||
          !task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::SINGLE_THREADED;
 }
@@ skipping 33 matching lines @@
   // - The output surfaces are only valid on the client-side so they are
   //   therefore not serialized.
   // - LayerTreeSettings are needed only during construction of the
   //   LayerTreeHost, so they are serialized outside of the LayerTreeHost
   //   serialization.
   // - The |visible_| flag will be controlled from the client separately and
   //   will need special handling outside of the serialization of the
   //   LayerTreeHost.
   // TODO(nyquist): Figure out how to support animations. See crbug.com/570376.
   TRACE_EVENT0("cc.remote", "LayerTreeHost::ToProtobufForCommit");
-  swap_promises->swap(swap_promise_list_);
-  DCHECK(swap_promise_list_.empty());
+  *swap_promises = swap_promise_manager_->TakeSwapPromises();
 
   proto->set_source_frame_number(source_frame_number_);
 
   // Serialize the LayerTree before serializing the properties. During layer
   // property serialization, we clear the list |layer_that_should_properties_|
   // from the LayerTree.
   layer_tree_->ToProtobuf(proto->mutable_layer_tree());
 
   LayerProtoConverter::SerializeLayerProperties(this,
                                                 proto->mutable_layer_updates());
 
   std::vector<PictureData> pictures =
       engine_picture_cache_->CalculateCacheUpdateAndFlush();
   proto::PictureDataVectorToSkPicturesProto(pictures,
                                             proto->mutable_pictures());
 
   debug_state_.ToProtobuf(proto->mutable_debug_state());
   proto->set_has_gpu_rasterization_trigger(has_gpu_rasterization_trigger_);
   proto->set_content_is_suitable_for_gpu_rasterization(
       content_is_suitable_for_gpu_rasterization_);
   proto->set_id(id_);
   proto->set_next_commit_forces_redraw(next_commit_forces_redraw_);
 
-  proto->set_surface_client_id(surface_client_id_);
-  proto->set_next_surface_sequence(next_surface_sequence_);
-
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       "cc.remote", "LayerTreeHostProto", source_frame_number_,
       ComputeLayerTreeHostProtoSizeSplitAsValue(proto));
 }
 
 void LayerTreeHost::FromProtobufForCommit(const proto::LayerTreeHost& proto) {
   DCHECK(client_picture_cache_);
   source_frame_number_ = proto.source_frame_number();
 
   layer_tree_->FromProtobuf(proto.layer_tree());
@@ skipping 10 matching lines @@
 
   // The deserialization is finished, so now clear the cache.
   client_picture_cache_->Flush();
 
   debug_state_.FromProtobuf(proto.debug_state());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
-
-  surface_client_id_ = proto.surface_client_id();
-  next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc