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

cc/blimp/compositor_state_deserializer.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/compositor_state_deserializer.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "cc/blimp/client_picture_cache.h"
-#include "cc/blimp/compositor_state_deserializer_client.h"
 #include "cc/blimp/deserialized_content_layer_client.h"
 #include "cc/blimp/layer_factory.h"
 #include "cc/blimp/picture_data_conversions.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_scrollbar_layer.h"
 #include "cc/proto/cc_conversions.h"
+#include "cc/proto/client_state_update.pb.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer_tree_host.pb.h"
 #include "cc/proto/skia_conversions.h"
-#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_host_common.h"
+#include "cc/trees/layer_tree_host_in_process.h"
 
 namespace cc {
 namespace {
 
 class DefaultLayerFactory : public LayerFactory {
  public:
   DefaultLayerFactory() = default;
   ~DefaultLayerFactory() override = default;
 
   // LayerFactory implementation.
@@ skipping 32 matching lines @@
 CompositorStateDeserializer::LayerData::LayerData() = default;
 
 CompositorStateDeserializer::LayerData::~LayerData() = default;
 
 CompositorStateDeserializer::LayerData::LayerData(LayerData&& other) = default;
 
 CompositorStateDeserializer::LayerData& CompositorStateDeserializer::LayerData::
 operator=(LayerData&& other) = default;
 
 CompositorStateDeserializer::CompositorStateDeserializer(
-    LayerTreeHost* layer_tree_host,
+    LayerTreeHostInProcess* layer_tree_host,
     std::unique_ptr<ClientPictureCache> client_picture_cache,
-    const ScrollCallback& scroll_callback,
     CompositorStateDeserializerClient* client)
     : layer_factory_(base::MakeUnique<DefaultLayerFactory>()),
       layer_tree_host_(layer_tree_host),
       client_picture_cache_(std::move(client_picture_cache)),
-      scroll_callback_(scroll_callback),
-      client_(client) {
+      client_(client),
+      weak_factory_(this) {
   DCHECK(layer_tree_host_);
   DCHECK(client_);
 }
 
 CompositorStateDeserializer::~CompositorStateDeserializer() = default;
 
 Layer* CompositorStateDeserializer::GetLayerForEngineId(
     int engine_layer_id) const {
   EngineIdToLayerMap::const_iterator layer_it =
       engine_id_to_layer_.find(engine_layer_id);
@@ skipping 20 matching lines @@
 
   // The deserialization is finished, so now clear the cache.
   client_picture_cache_->Flush();
 }
 
 void CompositorStateDeserializer::SetLayerFactoryForTesting(
     std::unique_ptr<LayerFactory> layer_factory) {
   layer_factory_ = std::move(layer_factory);
 }
 
+void CompositorStateDeserializer::ApplyViewportDeltas(
+    const gfx::Vector2dF& inner_delta,
+    const gfx::Vector2dF& outer_delta,
+    const gfx::Vector2dF& elastic_overscroll_delta,
+    float page_scale,
+    float top_controls_delta) {
+  DCHECK_EQ(top_controls_delta, 0.0f);
+  DCHECK(elastic_overscroll_delta == gfx::Vector2dF());
+  DCHECK(outer_delta == gfx::Vector2dF());
+
+  // The inner_delta can be ignored here, since we receive that in the scroll
+  // callback on the layer itself.
+  if (page_scale != 1.0f) {
+    LayerTree* layer_tree = layer_tree_host_->GetLayerTree();
+    synced_page_scale_.UpdateDeltaFromImplThread(
+        layer_tree->page_scale_factor());
+    layer_tree->SetPageScaleFactorAndLimits(
+        synced_page_scale_.EngineMain(), layer_tree->min_page_scale_factor(),
+        layer_tree->max_page_scale_factor());
+    client_->DidUpdateLocalState();
+  }
+}
+
+void CompositorStateDeserializer::PullClientStateUpdate(
+    proto::ClientStateUpdate* client_state_update) {
+  for (auto& layer_it : engine_id_to_layer_) {
+    int engine_layer_id = layer_it.first;
+    auto& synced_scroll_offset = layer_it.second.synced_scroll_offset;
+    gfx::ScrollOffset scroll_offset_delta =
+        synced_scroll_offset.PullDeltaForEngineUpdate();
+    gfx::Vector2dF scroll_delta_vector =
+        gfx::ScrollOffsetToVector2dF(scroll_offset_delta);
+
+    if (scroll_delta_vector.IsZero()) {
+      continue;
+    }
+
+    proto::ScrollUpdate* scroll_update =
+        client_state_update->add_scroll_updates();
+    scroll_update->set_layer_id(engine_layer_id);
+    Vector2dFToProto(scroll_delta_vector,
+                     scroll_update->mutable_scroll_delta());
+  }
+
+  float page_scale_delta = synced_page_scale_.PullDeltaForEngineUpdate();
+  if (page_scale_delta != 1.0f) {
+    client_state_update->set_page_scale_delta(page_scale_delta);
+  }
+}
+
+void CompositorStateDeserializer::DidApplyStateUpdatesOnEngine() {
+  for (auto& layer_it : engine_id_to_layer_) {
+    Layer* layer = layer_it.second.layer.get();
+    auto& synced_scroll_offset = layer_it.second.synced_scroll_offset;
+
+    synced_scroll_offset.DidApplySentDeltaOnEngine();
+    layer->SetScrollOffset(synced_scroll_offset.EngineMain());
+  }
+
+  synced_page_scale_.DidApplySentDeltaOnEngine();
+  LayerTree* layer_tree = layer_tree_host_->GetLayerTree();
+  layer_tree->SetPageScaleFactorAndLimits(synced_page_scale_.EngineMain(),
+                                          layer_tree->min_page_scale_factor(),
+                                          layer_tree->max_page_scale_factor());
+}
+
+void CompositorStateDeserializer::SendUnappliedDeltasToLayerTreeHost() {
+  std::unique_ptr<ReflectedMainFrameState> reflected_main_frame_state =
+      base::MakeUnique<ReflectedMainFrameState>();
+
+  for (auto& layer_it : engine_id_to_layer_) {
+    Layer* layer = layer_it.second.layer.get();
+    auto& synced_scroll_offset = layer_it.second.synced_scroll_offset;
+
+    gfx::ScrollOffset scroll_offset_delta =
+        synced_scroll_offset.DeltaNotAppliedOnEngine();
+    gfx::Vector2dF scroll_delta_vector =
+        gfx::ScrollOffsetToVector2dF(scroll_offset_delta);
+    if (scroll_delta_vector.IsZero())
+      continue;
+
+    ReflectedMainFrameState::ScrollUpdate scroll_update;
+    scroll_update.layer_id = layer->id();
+    scroll_update.scroll_delta = scroll_delta_vector;
+    reflected_main_frame_state->scrolls.push_back(scroll_update);
+  }
+
+  reflected_main_frame_state->page_scale_delta =
+      synced_page_scale_.DeltaNotAppliedOnEngine();
+  layer_tree_host_->SetReflectedMainFrameState(
+      std::move(reflected_main_frame_state));
+}
+
 void CompositorStateDeserializer::SychronizeLayerTreeState(
     const proto::LayerTree& layer_tree_proto) {
   LayerTree* layer_tree = layer_tree_host_->GetLayerTree();
 
   // Synchronize the tree hierarchy first.
   // TODO(khushalsagar): Don't do this if the hierarchy didn't change. See
   // crbug.com/605170.
   EngineIdToLayerMap new_engine_id_to_layer;
   ScrollbarLayerToScrollLayerId scrollbar_layer_to_scroll_layer;
   if (layer_tree_proto.has_root_layer()) {
@@ skipping 32 matching lines @@
       GetLayer(layer_tree_proto.inner_viewport_scroll_layer_id()),
       GetLayer(layer_tree_proto.outer_viewport_scroll_layer_id()));
 
   layer_tree->SetDeviceScaleFactor(layer_tree_proto.device_scale_factor());
   layer_tree->SetPaintedDeviceScaleFactor(
       layer_tree_proto.painted_device_scale_factor());
 
   float min_page_scale_factor = layer_tree_proto.min_page_scale_factor();
   float max_page_scale_factor = layer_tree_proto.max_page_scale_factor();
   float page_scale_factor = layer_tree_proto.page_scale_factor();
-  if (client_->ShouldRetainClientPageScale(page_scale_factor))
-    page_scale_factor = layer_tree->page_scale_factor();
-  layer_tree->SetPageScaleFactorAndLimits(
-      page_scale_factor, min_page_scale_factor, max_page_scale_factor);
+  synced_page_scale_.PushFromEngineMainThread(page_scale_factor);
+  layer_tree->SetPageScaleFactorAndLimits(synced_page_scale_.EngineMain(),
+                                          min_page_scale_factor,
+                                          max_page_scale_factor);
 
   layer_tree->set_background_color(layer_tree_proto.background_color());
   layer_tree->set_has_transparent_background(
       layer_tree_proto.has_transparent_background());
 
   LayerSelection selection;
   LayerSelectionFromProtobuf(&selection, layer_tree_proto.selection());
   layer_tree->RegisterSelection(selection);
   layer_tree->SetViewportSize(
       ProtoToSize(layer_tree_proto.device_viewport_size()));
@@ skipping 31 matching lines @@
   layer->SetPosition(ProtoToPointF(base.position()));
   layer->SetTransform(ProtoToTransform(base.transform()));
   layer->SetTransformOrigin(ProtoToPoint3F(base.transform_origin()));
   layer->SetIsDrawable(base.is_drawable());
   layer->SetDoubleSided(base.double_sided());
   layer->SetShouldFlattenTransform(base.should_flatten_transform());
   layer->Set3dSortingContextId(base.sorting_context_id());
   layer->SetUseParentBackfaceVisibility(base.use_parent_backface_visibility());
   layer->SetBackgroundColor(base.background_color());
 
-  gfx::ScrollOffset scroll_offset = ProtoToScrollOffset(base.scroll_offset());
-  if (client_->ShouldRetainClientScroll(engine_layer_id, scroll_offset))
-    scroll_offset = layer->scroll_offset();
-  layer->SetScrollOffset(scroll_offset);
+  gfx::ScrollOffset engine_scroll_offset =
+      ProtoToScrollOffset(base.scroll_offset());
+  SyncedRemoteScrollOffset& synced_scroll_offset =
+      GetLayerData(engine_layer_id)->synced_scroll_offset;
+  synced_scroll_offset.PushFromEngineMainThread(engine_scroll_offset);
+  layer->SetScrollOffset(synced_scroll_offset.EngineMain());
 
   layer->SetScrollClipLayerId(
       GetClientIdFromEngineId(base.scroll_clip_layer_id()));
   layer->SetUserScrollable(base.user_scrollable_horizontal(),
                            base.user_scrollable_vertical());
 
   if (layer->main_thread_scrolling_reasons()) {
     layer->ClearMainThreadScrollingReasons(
         layer->main_thread_scrolling_reasons());
   }
@@ skipping 82 matching lines @@
         mask_layer_node, new_layer_map, scrollbar_layer_to_scroll_layer);
     layer->SetMaskLayer(mask_layer.get());
     SynchronizeLayerHierarchyRecursive(mask_layer.get(), mask_layer_node,
                                        new_layer_map,
                                        scrollbar_layer_to_scroll_layer);
   } else {
     layer->SetMaskLayer(nullptr);
   }
 
   // Scroll callback.
-  layer->set_did_scroll_callback(base::Bind(scroll_callback_, layer_node.id()));
+  layer->set_did_scroll_callback(
+      base::Bind(&CompositorStateDeserializer::LayerScrolled,
+                 weak_factory_.GetWeakPtr(), layer_node.id()));
 }
 
 scoped_refptr<Layer> CompositorStateDeserializer::GetLayerAndAddToNewMap(
     const proto::LayerNode& layer_node,
     EngineIdToLayerMap* new_layer_map,
     ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer) {
   DCHECK(new_layer_map->find(layer_node.id()) == new_layer_map->end())
       << "A LayerNode should have been de-serialized only once";
 
   scoped_refptr<Layer> layer;
@@ skipping 54 matching lines @@
     } break;
     case proto::LayerNode::HEADS_UP_DISPLAY_LAYER:
       // TODO(khushalsagar): Remove this from proto.
       NOTREACHED();
   }
 
   layer = layer_data.layer;
   return layer;
 }
 
+void CompositorStateDeserializer::LayerScrolled(int engine_layer_id) {
+  LayerData* layer_data = GetLayerData(engine_layer_id);
+  Layer* layer = layer_data->layer.get();
+  SyncedRemoteScrollOffset& synced_scroll_offset =
+      layer_data->synced_scroll_offset;
+  synced_scroll_offset.UpdateDeltaFromImplThread(layer->scroll_offset());
+  layer->SetScrollOffset(synced_scroll_offset.EngineMain());
+  client_->DidUpdateLocalState();
+}
+
 int CompositorStateDeserializer::GetClientIdFromEngineId(
     int engine_layer_id) const {
   Layer* layer = GetLayerForEngineId(engine_layer_id);
   return layer ? layer->id() : Layer::LayerIdLabels::INVALID_ID;
 }
 
 scoped_refptr<Layer> CompositorStateDeserializer::GetLayer(
     int engine_layer_id) const {
   EngineIdToLayerMap::const_iterator layer_it =
       engine_id_to_layer_.find(engine_layer_id);
   return layer_it != engine_id_to_layer_.end() ? layer_it->second.layer
                                                : nullptr;
 }
 
 DeserializedContentLayerClient*
 CompositorStateDeserializer::GetContentLayerClient(int engine_layer_id) const {
   EngineIdToLayerMap::const_iterator layer_it =
       engine_id_to_layer_.find(engine_layer_id);
   return layer_it != engine_id_to_layer_.end()
              ? layer_it->second.content_layer_client.get()
              : nullptr;
 }
 
+CompositorStateDeserializer::LayerData*
+CompositorStateDeserializer::GetLayerData(int engine_layer_id) {
+  EngineIdToLayerMap::iterator layer_it =
+      engine_id_to_layer_.find(engine_layer_id);
+  return layer_it != engine_id_to_layer_.end() ? &layer_it->second : nullptr;
+}
+
 }  // namespace cc