cc/blimp: Add synchronization for scroll/scale state.

blimp/engine/renderer/blimp_remote_compositor_bridge.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 "blimp/engine/renderer/blimp_remote_compositor_bridge.h"
 
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/remote_compositor_bridge_client.h"
 #include "cc/output/swap_promise.h"
 #include "cc/proto/compositor_message.pb.h"
 
 namespace blimp {
 namespace engine {
 
 BlimpRemoteCompositorBridge::BlimpRemoteCompositorBridge(
     cc::RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_main_task_runner)
     : RemoteCompositorBridge(std::move(compositor_main_task_runner)),
       remote_proto_channel_(remote_proto_channel),
       scheduler_(compositor_main_task_runner_.get(), this) {
   remote_proto_channel_->SetProtoReceiver(this);
 }
 
-BlimpRemoteCompositorBridge::~BlimpRemoteCompositorBridge() = default;
+BlimpRemoteCompositorBridge::~BlimpRemoteCompositorBridge() {
+  remote_proto_channel_->SetProtoReceiver(nullptr);
+}
 
 void BlimpRemoteCompositorBridge::BindToClient(
     cc::RemoteCompositorBridgeClient* client) {
   DCHECK(!client_);
   client_ = client;
 }
 
 void BlimpRemoteCompositorBridge::ScheduleMainFrame() {
   scheduler_.ScheduleFrameUpdate();
 }
 
 void BlimpRemoteCompositorBridge::ProcessCompositorStateUpdate(
     std::unique_ptr<cc::CompositorProtoState> compositor_proto_state) {
+  compositor_proto_state->compositor_message->set_client_state_update_ack(
+      client_state_update_ack_pending_);
+  client_state_update_ack_pending_ = false;
+
   remote_proto_channel_->SendCompositorProto(
       *compositor_proto_state->compositor_message);
   scheduler_.DidSendFrameUpdateToClient();
 
   // Activate the swap promises after the frame is queued.
   for (const auto& swap_promise : compositor_proto_state->swap_promises)
     swap_promise->DidActivate();
 }
 
 void BlimpRemoteCompositorBridge::OnProtoReceived(
     std::unique_ptr<cc::proto::CompositorMessage> proto) {
-  DCHECK(proto->frame_ack());
-  scheduler_.DidReceiveFrameUpdateAck();
+  if (proto->frame_ack())
+    scheduler_.DidReceiveFrameUpdateAck();
+
+  if (proto->has_client_state_update()) {
+    DCHECK(!client_state_update_ack_pending_);
+
+    client_->ApplyStateUpdateFromClient(proto->client_state_update());
+
+    // If applying the delta resulted in a frame request, run the main frame
+    // first so the ack sent to the client includes the frame with the deltas
+    // applied.
+    if (scheduler_.needs_frame_update()) {
+      client_state_update_ack_pending_ = true;
+    } else {
+      cc::proto::CompositorMessage message;
+      message.set_client_state_update_ack(true);
+      remote_proto_channel_->SendCompositorProto(message);
+    }
+  }
 }
 
 void BlimpRemoteCompositorBridge::StartFrameUpdate() {
   client_->BeginMainFrame();
+
+  // If the frame resulted in an update to the client, the ack should have gone
+  // with it. If it is still pending, this means the main frame was aborted so
+  // send the ack now.
+  if (client_state_update_ack_pending_) {
+    client_state_update_ack_pending_ = false;
+    cc::proto::CompositorMessage message;
+    message.set_client_state_update_ack(true);
+    remote_proto_channel_->SendCompositorProto(message);
+  }
 }
 
 }  // namespace engine
 }  // namespace blimp