blimp: Use SwapPromises for readback API.

blimp/client/core/compositor/blimp_compositor.cc

 // 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.
 
 #include "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 42 matching lines @@
   cc::Surface* surface = manager->GetSurfaceForId(id);
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
+class BlimpCompositor::FrameTrackingSwapPromise : public cc::SwapPromise {
+ public:
+  FrameTrackingSwapPromise(
+      std::unique_ptr<cc::CopyOutputRequest> copy_request,
+      base::WeakPtr<BlimpCompositor> compositor,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+      : copy_request_(std::move(copy_request)),
+        compositor_weak_ptr_(compositor),
+        main_task_runner_(std::move(main_task_runner)) {}
+  ~FrameTrackingSwapPromise() override = default;
+
+  // cc::SwapPromise implementation.
+  void DidActivate() override {}
+  void DidSwap(cc::CompositorFrameMetadata* metadata) override {
+    // DidSwap is called right before the CompositorFrame is submitted to the
+    // CompositorFrameSink, so we make sure to delay the copy request till that
+    // frame is submitted.
+    main_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&BlimpCompositor::MakeCopyRequestOnNextSwap,
+                   compositor_weak_ptr_, base::Passed(&copy_request_)));
+  }
+  DidNotSwapAction DidNotSwap(DidNotSwapReason reason) override {
+    switch (reason) {
+      case DidNotSwapReason::SWAP_FAILS:
+        // The swap will fail if there is no frame damage, we can queue the
+        // request right away.
+        main_task_runner_->PostTask(
+            FROM_HERE, base::Bind(&BlimpCompositor::RequestCopyOfOutput,
+                                  compositor_weak_ptr_,
+                                  base::Passed(&copy_request_), false));
+        break;
+      case DidNotSwapReason::COMMIT_FAILS:
+        // The commit fails when the host is going away.
+        break;
+      case DidNotSwapReason::COMMIT_NO_UPDATE:
+        main_task_runner_->PostTask(
+            FROM_HERE, base::Bind(&BlimpCompositor::RequestCopyOfOutput,
+                                  compositor_weak_ptr_,
+                                  base::Passed(&copy_request_), false));
+        break;
+      case DidNotSwapReason::ACTIVATION_FAILS:
+        // Failure to activate the pending tree implies either the host in going
+        // away or the FrameSink was lost.
+        break;
+    }
+    return DidNotSwapAction::BREAK_PROMISE;
+  }
+  int64_t TraceId() const override { return 0; }
+
+ private:
+  std::unique_ptr<cc::CopyOutputRequest> copy_request_;
+  base::WeakPtr<BlimpCompositor> compositor_weak_ptr_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+};
+
 BlimpCompositor::BlimpCompositor(
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client,
     bool use_threaded_layer_tree_host)
     : use_threaded_layer_tree_host_(use_threaded_layer_tree_host),
       client_(client),
       compositor_dependencies_(compositor_dependencies),
       frame_sink_id_(compositor_dependencies_->GetEmbedderDependencies()
                          ->AllocateFrameSinkId()),
       proxy_client_(nullptr),
@@ skipping 19 matching lines @@
                        weak_ptr_factory_.GetWeakPtr()),
             this);
   }
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
-
-  CheckPendingCommitCounts(true /* flush */);
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
-
-  if (!visible)
-    CheckPendingCommitCounts(true /* flush */);
 }
 
-void BlimpCompositor::NotifyWhenDonePendingCommits(base::Closure callback) {
+void BlimpCompositor::RequestCopyOfOutput(
+    std::unique_ptr<cc::CopyOutputRequest> copy_request,
+    bool flush_pending_update) {
+  // If we don't have a FrameSink, fail right away.
+  if (!surface_factory_)
+    return;
+
+  if (!use_threaded_layer_tree_host_) {
+    RequestCopyOfOutputDeprecated(std::move(copy_request));
+    return;
+  }
+
+  if (flush_pending_update) {
+    // Always request a commit when queuing the promise to make sure that any
+    // frames pending draws are cleared from the pipeline.
+    host_->QueueSwapPromise(base::MakeUnique<FrameTrackingSwapPromise>(
+        std::move(copy_request), weak_ptr_factory_.GetWeakPtr(),
+        base::ThreadTaskRunnerHandle::Get()));
+    host_->SetNeedsCommit();
+  } else if (!local_frame_id_.is_null()) {
+    // Make a copy request for the surface directly.
+    surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                           std::move(copy_request));
+  }
+}
+
+void BlimpCompositor::RequestCopyOfOutputDeprecated(
+    std::unique_ptr<cc::CopyOutputRequest> copy_request) {
+  DCHECK(!use_threaded_layer_tree_host_);
+
   if (outstanding_commits_ == 0) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+    surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                           std::move(copy_request));
     return;
   }
 
   pending_commit_trackers_.push_back(
-      std::make_pair(outstanding_commits_, callback));
+      std::make_pair(outstanding_commits_, std::move(copy_request)));
 }
 
 void BlimpCompositor::UpdateLayerTreeHost() {
   if (pending_frame_update_) {
     DCHECK(use_threaded_layer_tree_host_);
     compositor_state_deserializer_->DeserializeCompositorUpdate(
         pending_frame_update_->layer_tree_host());
     pending_frame_update_ = nullptr;
     cc::proto::CompositorMessage frame_ack;
     frame_ack.set_frame_ack(true);
     client_->SendCompositorMessage(frame_ack);
   }
 }
 
 void BlimpCompositor::RequestNewCompositorFrameSink() {
   DCHECK(!surface_factory_);
   DCHECK(!compositor_frame_sink_request_pending_);
 
   compositor_frame_sink_request_pending_ = true;
   GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidInitializeCompositorFrameSink() {
   compositor_frame_sink_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
-  BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
+  if (use_threaded_layer_tree_host_)
+    return;
 
   DCHECK_GT(outstanding_commits_, 0U);
   outstanding_commits_--;
 
-  CheckPendingCommitCounts(false /* flush */);
+  for (auto it = pending_commit_trackers_.begin();
+       it != pending_commit_trackers_.end();) {
+    if (--it->first == 0) {
+      if (surface_factory_)
+        surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                               std::move(it->second));
+      it = pending_commit_trackers_.erase(it);
+    } else {
+      ++it;
+    }
+  }
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   DCHECK(!use_threaded_layer_tree_host_);
   remote_proto_channel_receiver_ = receiver;
 }
 
 void BlimpCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   DCHECK(!use_threaded_layer_tree_host_);
   client_->SendCompositorMessage(proto);
 }
 
 void BlimpCompositor::OnCompositorMessageReceived(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   if (message->has_to_impl()) {
     HandleCompositorMessageToImpl(std::move(message));
     return;
   }
 
   DCHECK(use_threaded_layer_tree_host_);
   DCHECK(message->has_layer_tree_host())
       << "The engine only sends frame updates";
   DCHECK(!pending_frame_update_)
       << "We should have only a single frame in flight";
 
   UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
                           (float)message->ByteSize() / 1024);
+  BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
   pending_frame_update_ = std::move(message);
-  outstanding_commits_++;
   host_->SetNeedsAnimate();
 }
 
 void BlimpCompositor::HandleCompositorMessageToImpl(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   DCHECK(!use_threaded_layer_tree_host_);
   DCHECK(message->has_to_impl());
 
   const cc::proto::CompositorMessageToImpl to_impl_proto = message->to_impl();
   DCHECK(to_impl_proto.has_message_type());
 
   if (to_impl_proto.message_type() ==
       cc::proto::CompositorMessageToImpl::START_COMMIT) {
+    BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
     outstanding_commits_++;
   }
 
   switch (to_impl_proto.message_type()) {
     case cc::proto::CompositorMessageToImpl::UNKNOWN:
       NOTIMPLEMENTED() << "Ignoring message of UNKNOWN type";
       break;
     case cc::proto::CompositorMessageToImpl::START_COMMIT:
       UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
                               (float)message->ByteSize() / 1024);
@@ skipping 77 matching lines @@
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
   surface_factory_->SubmitCompositorFrame(
       local_frame_id_, std::move(frame),
       base::Bind(&BlimpCompositor::SubmitCompositorFrameAck,
                  weak_ptr_factory_.GetWeakPtr()));
+
+  for (auto& copy_request : copy_requests_for_next_swap_) {
+    surface_factory_->RequestCopyOfSurface(local_frame_id_,
+                                           std::move(copy_request));
+  }
+  copy_requests_for_next_swap_.clear();
 }
 
 void BlimpCompositor::SubmitCompositorFrameAck() {
   DCHECK(surface_factory_);
   compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&BlimpCompositorFrameSinkProxyClient::SubmitCompositorFrameAck,
                  proxy_client_));
 }
 
+void BlimpCompositor::MakeCopyRequestOnNextSwap(
+    std::unique_ptr<cc::CopyOutputRequest> copy_request) {
+  copy_requests_for_next_swap_.push_back(std::move(copy_request));
+}
+
 void BlimpCompositor::UnbindProxyClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   DestroyDelegatedContent();
   surface_factory_.reset();
   proxy_client_ = nullptr;
 }
 
 void BlimpCompositor::ReturnResources(
@@ skipping 34 matching lines @@
 
   // Remove any references for the surface layer that uses this
   // |local_frame_id_|.
   layer_->RemoveAllChildren();
   surface_factory_->Destroy(local_frame_id_);
   local_frame_id_ = cc::LocalFrameId();
 }
 
 void BlimpCompositor::CreateLayerTreeHost() {
   DCHECK(!host_);
-  VLOG(1) << "Creating LayerTreeHost.";
 
   // Create the LayerTreeHost
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
   params.gpu_memory_buffer_manager =
       GetEmbedderDeps()->GetGpuMemoryBufferManager();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   if (!use_threaded_layer_tree_host_) {
     params.image_serialization_processor =
@@ skipping 13 matching lines @@
     host_ = cc::LayerTreeHostInProcess::CreateThreaded(compositor_task_runner,
                                                        &params);
   } else {
     host_ = cc::LayerTreeHostInProcess::CreateRemoteClient(
         this /* remote_proto_channel */, compositor_task_runner, &params);
   }
 }
 
 void BlimpCompositor::DestroyLayerTreeHost() {
   DCHECK(host_);
-  VLOG(1) << "Destroying LayerTreeHost.";
 
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   DestroyDelegatedContent();
   surface_factory_.reset();
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
-void BlimpCompositor::CheckPendingCommitCounts(bool flush) {
-  for (auto it = pending_commit_trackers_.begin();
-       it != pending_commit_trackers_.end();) {
-    if (flush || --it->first == 0) {
-      it->second.Run();
-      it = pending_commit_trackers_.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
 }  // namespace client
 }  // namespace blimp