blimp: Update page load status update indicator to use first paint.

cc/trees/remote_channel_main.cc

 // Copyright 2016 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/remote_channel_main.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "cc/proto/base_conversions.h"
@@ skipping 159 matching lines @@
     CompletionEvent* completion,
     LayerTreeHost* layer_tree_host,
     base::TimeTicks main_thread_start_time,
     bool hold_commit_for_activation) {
   TRACE_EVENT0("cc.remote", "RemoteChannelMain::StartCommitOnImpl");
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(proto::CompositorMessageToImpl::START_COMMIT);
   proto::StartCommit* start_commit_message =
       to_impl_proto->mutable_start_commit_message();
+  std::vector<std::unique_ptr<SwapPromise>> swap_promises;
   layer_tree_host->ToProtobufForCommit(
-      start_commit_message->mutable_layer_tree_host());
+      start_commit_message->mutable_layer_tree_host(), &swap_promises);
 
   VLOG(1) << "Sending commit message to client. Commit bytes size: "
           << proto.ByteSize();
   SendMessageProto(proto);
 
+  // Activate the swap promises after the commit is queued.
+  // In the threaded compositor, activation implies that the pending tree on the
+  // impl thread has been activated. While the impl thread for the remote
+  // compositor is on the client, the embedder still expects to receive these
+  // events in order to drive decisions that depend on impl frame production.
+  // So we dispatch these events after a commit message is sent to the client.
+  // Sending the commit message implies that a visual update has been queued for
+  // the client, which is the closest we can come to offering an indicator akin
+  // to an impl frame queued for display.
+  for (const auto& swap_promise : swap_promises)
+    swap_promise->DidActivate();
+
   // In order to avoid incurring the overhead for the client to send us a
   // message for when a frame to be committed is drawn we inform the embedder
   // that the draw was successful immediately after sending the commit message.
   // Since the compositing state may be used by the embedder to throttle
   // commit/draw requests, it is better to allow them to propagate rather than
   // incurring a round-trip to get Acks for draw from the client for each frame.
 
   // This is done as a separate PostTask to ensure that these calls run after
   // LayerTreeHostClient::DidCommit and stay consistent with the
   // behaviour in the threaded compositor.
@@ skipping 73 matching lines @@
 
 void RemoteChannelMain::DidCompleteSwapBuffers() {
   proxy_main_->DidCompleteSwapBuffers();
 }
 
 base::SingleThreadTaskRunner* RemoteChannelMain::MainThreadTaskRunner() const {
   return task_runner_provider_->MainThreadTaskRunner();
 }
 
 }  // namespace cc