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/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_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.
  scoped_refptr<Layer> CreateLayer(int engine_layer_id) override {
    return Layer::Create();
  }
  scoped_refptr<PictureLayer> CreatePictureLayer(
      int engine_layer_id,
      ContentLayerClient* content_layer_client) override {
    return PictureLayer::Create(content_layer_client);
  }
  scoped_refptr<SolidColorScrollbarLayer> CreateSolidColorScrollbarLayer(
      int engine_layer_id,
      ScrollbarOrientation orientation,
      int thumb_thickness,
      int track_start,
      bool is_left_side_vertical_scrollbar,
      int scroll_layer_id) override {
    return SolidColorScrollbarLayer::Create(
        orientation, thumb_thickness, track_start,
        is_left_side_vertical_scrollbar, scroll_layer_id);
  }
  scoped_refptr<PictureLayer> CreateFakePictureLayer(
      int engine_layer_id,
      ContentLayerClient* content_layer_client) override {
    // We should never create fake layers in production code.
    NOTREACHED();
    return PictureLayer::Create(content_layer_client);
  }
  scoped_refptr<Layer> CreatePushPropertiesCountingLayer(
      int engine_layer_id) override {
    // We should never create fake layers in production code.
    NOTREACHED();
    return Layer::Create();
  }
};

}  // namespace

CompositorStateDeserializer::LayerData::LayerData() = default;

CompositorStateDeserializer::LayerData::~LayerData() = default;

CompositorStateDeserializer::LayerData::LayerData(LayerData&& other) = default;

CompositorStateDeserializer::LayerData& CompositorStateDeserializer::LayerData::
operator=(LayerData&& other) = default;

CompositorStateDeserializer::CompositorStateDeserializer(
    LayerTreeHostInProcess* layer_tree_host,
    std::unique_ptr<ClientPictureCache> client_picture_cache,
    CompositorStateDeserializerClient* client)
    : layer_factory_(base::MakeUnique<DefaultLayerFactory>()),
      layer_tree_host_(layer_tree_host),
      client_picture_cache_(std::move(client_picture_cache)),
      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);
  return layer_it != engine_id_to_layer_.end() ? layer_it->second.layer.get()
                                               : nullptr;
}

void CompositorStateDeserializer::DeserializeCompositorUpdate(
    const proto::LayerTreeHost& layer_tree_host_proto) {
  SychronizeLayerTreeState(layer_tree_host_proto.layer_tree());

  // Ensure ClientPictureCache contains all the necessary SkPictures before
  // deserializing the properties.
  proto::SkPictures proto_pictures = layer_tree_host_proto.pictures();
  std::vector<PictureData> pictures =
      SkPicturesProtoToPictureDataVector(proto_pictures);
  client_picture_cache_->ApplyCacheUpdate(pictures);

  const proto::LayerUpdate& layer_updates =
      layer_tree_host_proto.layer_updates();
  for (int i = 0; i < layer_updates.layers_size(); ++i) {
    SynchronizeLayerState(layer_updates.layers(i));
  }

  // 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()) {
    const proto::LayerNode& root_layer_node = layer_tree_proto.root_layer();
    layer_tree->SetRootLayer(
        GetLayerAndAddToNewMap(root_layer_node, &new_engine_id_to_layer,
                               &scrollbar_layer_to_scroll_layer));
    SynchronizeLayerHierarchyRecursive(layer_tree->root_layer(),
                                       root_layer_node, &new_engine_id_to_layer,
                                       &scrollbar_layer_to_scroll_layer);
  } else {
    layer_tree->SetRootLayer(nullptr);
  }
  engine_id_to_layer_.swap(new_engine_id_to_layer);

  // Now that the tree has been synced, we can set up the scroll layers, since
  // the corresponding engine layers have been created.
  for (const auto& scrollbar : scrollbar_layer_to_scroll_layer) {
    // This corresponds to the id of the Scrollbar Layer.
    int scrollbar_layer_id = scrollbar.first;

    // This corresponds to the id of the scroll layer for this scrollbar.
    int scroll_layer_id = scrollbar.second;

    SolidColorScrollbarLayer* scrollbar_layer =
        static_cast<SolidColorScrollbarLayer*>(
            GetLayerForEngineId(scrollbar_layer_id));

    scrollbar_layer->SetScrollLayer(GetClientIdFromEngineId(scroll_layer_id));
  }

  // Synchronize rest of the tree state.
  layer_tree->RegisterViewportLayers(
      GetLayer(layer_tree_proto.overscroll_elasticity_layer_id()),
      GetLayer(layer_tree_proto.page_scale_layer_id()),
      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();
  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()));

  layer_tree->SetHaveScrollEventHandlers(
      layer_tree_proto.have_scroll_event_handlers());
  layer_tree->SetEventListenerProperties(
      EventListenerClass::kMouseWheel,
      static_cast<EventListenerProperties>(
          layer_tree_proto.wheel_event_listener_properties()));
  layer_tree->SetEventListenerProperties(
      EventListenerClass::kTouchStartOrMove,
      static_cast<EventListenerProperties>(
          layer_tree_proto.touch_start_or_move_event_listener_properties()));
  layer_tree->SetEventListenerProperties(
      EventListenerClass::kTouchEndOrCancel,
      static_cast<EventListenerProperties>(
          layer_tree_proto.touch_end_or_cancel_event_listener_properties()));
}

void CompositorStateDeserializer::SynchronizeLayerState(
    const proto::LayerProperties& layer_properties_proto) {
  int engine_layer_id = layer_properties_proto.id();
  Layer* layer = GetLayerForEngineId(engine_layer_id);

  // Layer Inputs -----------------------------------------------------
  const proto::BaseLayerProperties& base = layer_properties_proto.base();
  layer->SetNeedsDisplayRect(ProtoToRect(base.update_rect()));
  layer->SetBounds(ProtoToSize(base.bounds()));
  layer->SetMasksToBounds(base.masks_to_bounds());
  layer->SetOpacity(base.opacity());
  layer->SetBlendMode(SkXfermodeModeFromProto(base.blend_mode()));
  layer->SetIsRootForIsolatedGroup(base.is_root_for_isolated_group());
  layer->SetContentsOpaque(base.contents_opaque());
  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 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());
  }
  if (base.main_thread_scrolling_reasons()) {
    layer->AddMainThreadScrollingReasons(base.main_thread_scrolling_reasons());
  }

  layer->SetNonFastScrollableRegion(
      RegionFromProto(base.non_fast_scrollable_region()));
  layer->SetTouchEventHandlerRegion(
      RegionFromProto(base.touch_event_handler_region()));

  layer->SetIsContainerForFixedPositionLayers(
      base.is_container_for_fixed_position_layers());

  LayerPositionConstraint position_constraint;
  position_constraint.FromProtobuf(base.position_constraint());
  layer->SetPositionConstraint(position_constraint);

  LayerStickyPositionConstraint sticky_position_constraint;
  sticky_position_constraint.FromProtobuf(base.sticky_position_constraint());
  layer->SetStickyPositionConstraint(sticky_position_constraint);
  layer->SetScrollParent(GetLayerForEngineId(base.scroll_parent_id()));
  layer->SetClipParent(GetLayerForEngineId(base.clip_parent_id()));

  layer->SetHasWillChangeTransformHint(base.has_will_change_transform_hint());
  layer->SetHideLayerAndSubtree(base.hide_layer_and_subtree());

  // ------------------------------------------------------------------

  // PictureLayer Properties deserialization.
  if (layer_properties_proto.has_picture()) {
    const proto::PictureLayerProperties& picture_properties =
        layer_properties_proto.picture();

    // Only PictureLayers set picture.
    PictureLayer* picture_layer =
        static_cast<PictureLayer*>(GetLayerForEngineId(engine_layer_id));
    picture_layer->SetNearestNeighbor(picture_properties.nearest_neighbor());

    gfx::Rect recorded_viewport =
        ProtoToRect(picture_properties.recorded_viewport());
    scoped_refptr<DisplayItemList> display_list;
    std::vector<uint32_t> used_engine_picture_ids;
    if (picture_properties.has_display_list()) {
      display_list = DisplayItemList::CreateFromProto(
          picture_properties.display_list(), client_picture_cache_.get(),
          &used_engine_picture_ids);
    } else {
      display_list = nullptr;
    }

    // TODO(khushalsagar): The caching here is sub-optimal. If a layer does not
    // PushProperties, its pictures won't get counted here even if the layer
    // is drawn in the current frame.
    for (uint32_t engine_picture_id : used_engine_picture_ids)
      client_picture_cache_->MarkUsed(engine_picture_id);

    GetContentLayerClient(engine_layer_id)
        ->UpdateDisplayListAndRecordedViewport(display_list, recorded_viewport);
  }
}

void CompositorStateDeserializer::SynchronizeLayerHierarchyRecursive(
    Layer* layer,
    const proto::LayerNode& layer_node,
    EngineIdToLayerMap* new_layer_map,
    ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer) {
  layer->RemoveAllChildren();

  // Children.
  for (int i = 0; i < layer_node.children_size(); i++) {
    const proto::LayerNode& child_layer_node = layer_node.children(i);
    scoped_refptr<Layer> child_layer = GetLayerAndAddToNewMap(
        child_layer_node, new_layer_map, scrollbar_layer_to_scroll_layer);
    layer->AddChild(child_layer);
    SynchronizeLayerHierarchyRecursive(child_layer.get(), child_layer_node,
                                       new_layer_map,
                                       scrollbar_layer_to_scroll_layer);
  }

  // Mask Layer.
  if (layer_node.has_mask_layer()) {
    const proto::LayerNode& mask_layer_node = layer_node.mask_layer();
    scoped_refptr<Layer> mask_layer = GetLayerAndAddToNewMap(
        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(&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;
  EngineIdToLayerMap::iterator layer_map_it =
      engine_id_to_layer_.find(layer_node.id());

  if (layer_map_it != engine_id_to_layer_.end()) {
    // We can re-use the old layer.
    layer = layer_map_it->second.layer;
    (*new_layer_map)[layer_node.id()] = std::move(layer_map_it->second);
    engine_id_to_layer_.erase(layer_map_it);
    return layer;
  }

  // We need to create a new layer.
  auto& layer_data = (*new_layer_map)[layer_node.id()];
  switch (layer_node.type()) {
    case proto::LayerNode::UNKNOWN:
      NOTREACHED() << "Unknown Layer type";
    case proto::LayerNode::LAYER:
      layer_data.layer = layer_factory_->CreateLayer(layer_node.id());
      break;
    case proto::LayerNode::PICTURE_LAYER:
      layer_data.content_layer_client =
          base::MakeUnique<DeserializedContentLayerClient>();
      layer_data.layer = layer_factory_->CreatePictureLayer(
          layer_node.id(), layer_data.content_layer_client.get());
      break;
    case proto::LayerNode::FAKE_PICTURE_LAYER:
      // FAKE_PICTURE_LAYER is for testing only.
      layer_data.content_layer_client =
          base::MakeUnique<DeserializedContentLayerClient>();
      layer_data.layer = layer_factory_->CreateFakePictureLayer(
          layer_node.id(), layer_data.content_layer_client.get());
      break;
    case proto::LayerNode::SOLID_COLOR_SCROLLBAR_LAYER: {
      // SolidColorScrollbarLayers attach their properties in the LayerNode
      // itself.
      const proto::SolidColorScrollbarLayerProperties& scrollbar =
          layer_node.solid_scrollbar();

      DCHECK(scrollbar_layer_to_scroll_layer->find(layer_node.id()) ==
             scrollbar_layer_to_scroll_layer->end());
      int scroll_layer_id = scrollbar.scroll_layer_id();
      (*scrollbar_layer_to_scroll_layer)[layer_node.id()] = scroll_layer_id;

      int thumb_thickness = scrollbar.thumb_thickness();
      int track_start = scrollbar.track_start();
      bool is_left_side_vertical_scrollbar =
          scrollbar.is_left_side_vertical_scrollbar();
      ScrollbarOrientation orientation =
          ScrollbarOrientationFromProto(scrollbar.orientation());

      // We use the invalid id for the |scroll_layer_id| because the
      // corresponding layer on the client may not have been created yet.
      layer_data.layer = layer_factory_->CreateSolidColorScrollbarLayer(
          layer_node.id(), orientation, thumb_thickness, track_start,
          is_left_side_vertical_scrollbar, Layer::LayerIdLabels::INVALID_ID);
    } break;
    case proto::LayerNode::PUSH_PROPERTIES_COUNTING_LAYER:
      // PUSH_PROPERTIES_COUNTING_LAYER is for testing only.
      layer_data.layer =
          layer_factory_->CreatePushPropertiesCountingLayer(layer_node.id());
      break;
  }

  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