// 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 CreateLayer(int engine_layer_id) override { return Layer::Create(); } scoped_refptr CreatePictureLayer( int engine_layer_id, ContentLayerClient* content_layer_client) override { return PictureLayer::Create(content_layer_client); } scoped_refptr 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 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 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 client_picture_cache, CompositorStateDeserializerClient* client) : layer_factory_(base::MakeUnique()), 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 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 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 reflected_main_frame_state = base::MakeUnique(); 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( 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( layer_tree_proto.wheel_event_listener_properties())); layer_tree->SetEventListenerProperties( EventListenerClass::kTouchStartOrMove, static_cast( layer_tree_proto.touch_start_or_move_event_listener_properties())); layer_tree->SetEventListenerProperties( EventListenerClass::kTouchEndOrCancel, static_cast( 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(GetLayerForEngineId(engine_layer_id)); picture_layer->SetNearestNeighbor(picture_properties.nearest_neighbor()); gfx::Rect recorded_viewport = ProtoToRect(picture_properties.recorded_viewport()); scoped_refptr display_list; std::vector 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 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 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 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; 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(); 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(); 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 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