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_)

[aelias_OOO_until_Jul13, 2016/11/02 07:02:10]

For my edification, what is !use_threaded_layer_tree_host_ mode used for?

[Khushal, 2016/11/02 07:24:21]

Right now our split point in the pipeline is right in the middle of the thread
boundary. cc::RemoteChannelImpl has the details on how it works but basically we
throw in a network pipe to ship messages across the network instead of posting
tasks across threads. The !use_threaded_layer_tree_host_ is that mode.

The use_threaded_layer_tree_host_ mode instead makes blimp an embedder of the
threaded compositor on the client, so the split is exactly between blink and cc.
This is all just staging code for the transition while we remove the former code
path.

+    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