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

cc/blimp/layer_tree_host_remote.cc

Index: cc/blimp/layer_tree_host_remote.cc
diff --git a/cc/blimp/layer_tree_host_remote.cc b/cc/blimp/layer_tree_host_remote.cc
index 290a601c111b3b8af3033394ce1dac9118d8f89d..276f5927dae26f4db7c74af69110036f60558bd4 100644
--- a/cc/blimp/layer_tree_host_remote.cc
+++ b/cc/blimp/layer_tree_host_remote.cc
@@ -15,6 +15,7 @@
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_sink.h"
 #include "cc/proto/compositor_message.pb.h"
+#include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer_tree_host.pb.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/layer_tree_host_client.h"
@@ -222,7 +223,7 @@ void LayerTreeHostRemote::SetNextCommitForcesRedraw() {
   // Ideally the engine shouldn't need to care about draw requests at all. The
   // compositor that produces CompositorFrames is on the client and draw
   // requests should be made directly to it on the client itself.
-  NOTREACHED();
+  NOTIMPLEMENTED();
 }
 
 void LayerTreeHostRemote::NotifyInputThrottledUntilCommit() {
@@ -442,46 +443,52 @@ void LayerTreeHostRemote::BeginMainFrame() {
                  weak_factory_.GetWeakPtr()));
 }
 
-bool LayerTreeHostRemote::ApplyScrollAndScaleUpdateFromClient(
-    const ScrollOffsetMap& client_scroll_map,
-    float client_page_scale) {
+void LayerTreeHostRemote::ApplyStateUpdateFromClient(
+    const proto::ClientStateUpdate& client_state_update) {
   DCHECK(!synchronizing_client_updates_);
-
   base::AutoReset<bool> synchronizing_updates(&synchronizing_client_updates_,
                                               true);
-  bool layer_sync_successful = true;
-
-  gfx::Vector2dF inner_viewport_scroll_delta;
-  Layer* inner_viewport_scroll_layer =
-      layer_tree_->inner_viewport_scroll_layer();
-  for (const auto& client_scroll : client_scroll_map) {
-    Layer* layer = layer_tree_->LayerById(client_scroll.first);
-    const gfx::ScrollOffset& scroll_offset = client_scroll.second;
-
-    // Note the inner viewport scroll delta to report separately.
-    if (layer == inner_viewport_scroll_layer) {
-      inner_viewport_scroll_delta =
-          scroll_offset.DeltaFrom(layer->scroll_offset());
+
+  gfx::Vector2dF inner_viewport_delta;
+  for (int i = 0; i < client_state_update.scroll_updates_size(); ++i) {
+    const proto::ScrollUpdate& scroll_update =
+        client_state_update.scroll_updates(i);
+    int layer_id = scroll_update.layer_id();
+    Layer* layer = layer_tree_->LayerById(layer_id);
+    gfx::Vector2dF scroll_delta =
+        ProtoToVector2dF(scroll_update.scroll_delta());
+
+    if (!layer)
+      continue;
+
+    if (layer == layer_tree_->inner_viewport_scroll_layer()) {
+      inner_viewport_delta = scroll_delta;
+    } else {
+      layer->SetScrollOffsetFromImplSide(
+          gfx::ScrollOffsetWithDelta(layer->scroll_offset(), scroll_delta));
+      SetNeedsUpdateLayers();
     }
+  }
 
-    if (layer)
-      layer->SetScrollOffsetFromImplSide(scroll_offset);
-    else
-      layer_sync_successful = false;
+  if (!inner_viewport_delta.IsZero()) {
+    layer_tree_->inner_viewport_scroll_layer()->SetScrollOffsetFromImplSide(
+        gfx::ScrollOffsetWithDelta(
+            layer_tree_->inner_viewport_scroll_layer()->scroll_offset(),
+            inner_viewport_delta));
   }
 
   float page_scale_delta = 1.0f;
-  if (client_page_scale != layer_tree_->page_scale_factor()) {
-    page_scale_delta = client_page_scale / layer_tree_->page_scale_factor();
-    layer_tree_->SetPageScaleFromImplSide(client_page_scale);
+  if (client_state_update.has_page_scale_delta()) {
+    page_scale_delta = client_state_update.page_scale_delta();
+    layer_tree_->SetPageScaleFromImplSide(layer_tree_->page_scale_factor() *
+                                          page_scale_delta);
   }
 
-  if (!inner_viewport_scroll_delta.IsZero() || page_scale_delta != 1.0f) {
-    client_->ApplyViewportDeltas(inner_viewport_scroll_delta, gfx::Vector2dF(),
-                                 gfx::Vector2dF(), page_scale_delta, 1.0f);
+  if (!inner_viewport_delta.IsZero() || page_scale_delta != 1.0f) {
+    client_->ApplyViewportDeltas(inner_viewport_delta, gfx::Vector2dF(),
+                                 gfx::Vector2dF(), page_scale_delta, 0.0f);
+    SetNeedsUpdateLayers();
   }
-
-  return layer_sync_successful;
 }
 
 void LayerTreeHostRemote::MainFrameComplete() {