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

cc/blimp/layer_tree_host_remote.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/blimp/layer_tree_host_remote.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/engine_picture_cache.h"
 #include "cc/blimp/picture_data_conversions.h"
 #include "cc/blimp/remote_compositor_bridge.h"
 #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"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/task_runner_provider.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 namespace {
 // We use a 16ms default frame interval because the rate at which the engine
@@ skipping 162 matching lines @@
   // used here.
   // TODO(khushalsagar): The caller could be waiting for an Ack for this redraw.
   // We need a better solution for this. See crbug.com/651141.
   NOTIMPLEMENTED();
 }
 
 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() {
   // This notification is used in the case where the renderer handles an input
   // event, and needs to send an Ack to the browser when the resulting main
   // frame is committed. If the compositor is taking too long on the pending
   // tree, the commit processing will be delayed blocking all input as a result.
   // So this is used to have the compositor activate the pending tree faster, so
   // the pending commit can be processed.
   // In remote mode, we don't send such notifications to the client because the
@@ skipping 197 matching lines @@
   // right after the update is processed by the bridge.
   // TODO(khushalsagar): We can not really know what these callbacks end up
   // being used for. Consider migrating clients to understand/cope with the fact
   // that there is no actual compositing happening here.
   task_runner_provider_->MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeHostRemote::DispatchDrawAndSubmitCallbacks,
                  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;
+  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());
 
-    // 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());
+    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() {
   DCHECK_EQ(current_pipeline_stage_, FramePipelineStage::COMMIT);
 
   current_pipeline_stage_ = FramePipelineStage::NONE;
   max_pipeline_stage_for_current_frame_ = FramePipelineStage::NONE;
   source_frame_number_++;
 
   client_->DidCommit();
@@ skipping 25 matching lines @@
         layer_tree_host_proto->mutable_layer_updates(), inputs_only);
   layer_tree_->LayersThatShouldPushProperties().clear();
 
   std::vector<PictureData> pictures =
       engine_picture_cache_->CalculateCacheUpdateAndFlush();
   proto::PictureDataVectorToSkPicturesProto(
       pictures, layer_tree_host_proto->mutable_pictures());
 }
 
 }  // namespace cc