cc/blimp: Set up hooks for scroll/scale sync.

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/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
 // produces main frames doesn't matter.
 base::TimeDelta kDefaultFrameInterval = base::TimeDelta::FromMilliseconds(16);
 
 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
 }  // namespace
 
@@ skipping 122 matching lines @@
 void LayerTreeHostRemote::SetNeedsRecalculateRasterScales() {
   // This is used by devtools to reraster content after changing device
   // emulation modes, so doesn't need to be supported by Blimp.
 }
 
 bool LayerTreeHostRemote::BeginMainFrameRequested() const {
   return requested_pipeline_stage_for_next_frame_ != FramePipelineStage::NONE;
 }
 
 bool LayerTreeHostRemote::CommitRequested() const {
-  return requested_pipeline_stage_for_next_frame_ == FramePipelineStage::COMMIT;
+  // We report that a commit is in progress when synchronizing scroll and scale
+  // updates because in threaded mode, scroll/scale synchronization from the
+  // impl thread happens only during the main frame.
+  return synchronizing_client_updates_ ||
+         requested_pipeline_stage_for_next_frame_ == FramePipelineStage::COMMIT;
 }
 
 void LayerTreeHostRemote::SetDeferCommits(bool defer_commits) {
   defer_commits_ = defer_commits;
   ScheduleMainFrameIfNecessary();
 }
 
 void LayerTreeHostRemote::LayoutAndUpdateLayers() {
   NOTREACHED() << "Only supported in single-threaded mode and this class"
                << " does not support single-thread since it is out of process";
@@ skipping 230 matching lines @@
   // LayerTreeHostClient to throttle further frame updates, so dispatch them
   // 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::DispatchDrawAndSwapCallbacks,
                             weak_factory_.GetWeakPtr()));
 }
 
+bool LayerTreeHostRemote::ApplyScrollAndScaleUpdateFromClient(
+    const ScrollOffsetMap& client_scroll_map,
+    float client_page_scale) {
+  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)

[vmpstr, 2016/10/13 19:20:55]

It's a two line if statement, so braces aren't optional afaik.

[Khushal, 2016/10/13 19:59:02]

Oh, so that's the rule. Done.

+      inner_viewport_scroll_delta =
+          scroll_offset.DeltaFrom(layer->scroll_offset());
+
+    if (layer)
+      layer->SetScrollOffsetFromImplSide(scroll_offset);
+    else
+      layer_sync_successful = false;
+  }
+
+  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 (!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);
+  }
+
+  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();
   client_->DidBeginMainFrame();
 }
@@ skipping 23 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