blob: 60e06d0a61a56ba8d5ebb4d98b65fdabb3e60fdd [file] [log] [blame]
// 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 <unordered_map>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "cc/base/cc_export.h"
#include "cc/blimp/synced_property_remote.h"
#include "ui/gfx/geometry/scroll_offset.h"
namespace cc {
namespace proto {
class ClientStateUpdate;
class LayerNode;
class LayerProperties;
class LayerTree;
class LayerTreeHost;
} // namespace proto
class ClientPictureCache;
class DeserializedContentLayerClient;
class Layer;
class LayerFactory;
class LayerTreeHostInProcess;
class CC_EXPORT CompositorStateDeserializerClient {
virtual ~CompositorStateDeserializerClient() {}
// Used to inform the client that the local state received from the engine was
// modified on the impl thread and a ClientStateUpdate needs to be scheduled
// to synchronize it with the main thread on the engine.
virtual void DidUpdateLocalState() = 0;
// Deserializes the compositor updates into the LayerTreeHost.
class CC_EXPORT CompositorStateDeserializer {
LayerTreeHostInProcess* layer_tree_host,
std::unique_ptr<ClientPictureCache> client_picture_cache,
CompositorStateDeserializerClient* client);
// Returns the local layer on the client for the given |engine_layer_id|.
Layer* GetLayerForEngineId(int engine_layer_id) const;
// Deserializes the |layer_tree_host_proto| into the LayerTreeHost.
void DeserializeCompositorUpdate(
const proto::LayerTreeHost& layer_tree_host_proto);
// Allows tests to inject the LayerFactory.
void SetLayerFactoryForTesting(std::unique_ptr<LayerFactory> layer_factory);
// Updates any viewport related deltas that have been reported to the main
// thread from the impl thread.
void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
const gfx::Vector2dF& outer_delta,
const gfx::Vector2dF& elastic_overscroll_delta,
float page_scale,
float top_controls_delta);
// Pulls a state update for changes reported to the main thread, that need to
// be synchronized with the associated state on the engine main thread.
void PullClientStateUpdate(proto::ClientStateUpdate* client_state_update);
// Informs that the client state update pulled was applied to the main thread
// on the engine.
// Note that this assumes that the state update provided to the engine was
// reflected back by the engine. If the application of this update resulted in
// any changes to the main thread state on the engine, these must be
// de-serialized and applied to the LayerTreeHost before a frame is committed
// to the impl thread.
void DidApplyStateUpdatesOnEngine();
// Sends any deltas that have been received on the main thread, but have not
// yet been applied to the main thread state back to the impl thread. This
// must be called for every main frame sent to the impl thread.
void SendUnappliedDeltasToLayerTreeHost();
using SyncedRemoteScrollOffset =
// A holder for the Layer and any data tied to it.
struct LayerData {
LayerData(LayerData&& other);
LayerData& operator=(LayerData&& other);
scoped_refptr<Layer> layer;
// Set only for PictureLayers.
std::unique_ptr<DeserializedContentLayerClient> content_layer_client;
SyncedRemoteScrollOffset synced_scroll_offset;
using EngineIdToLayerMap = std::unordered_map<int, LayerData>;
// Map of the scrollbar layer id to the corresponding scroll layer id. Both
// ids refer to the engine layer id.
using ScrollbarLayerToScrollLayerId = std::unordered_map<int, int>;
void SychronizeLayerTreeState(const proto::LayerTree& layer_tree_proto);
void SynchronizeLayerState(
const proto::LayerProperties& layer_properties_proto);
void SynchronizeLayerHierarchyRecursive(
Layer* layer,
const proto::LayerNode& layer_node,
EngineIdToLayerMap* new_layer_map,
ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer);
scoped_refptr<Layer> GetLayerAndAddToNewMap(
const proto::LayerNode& layer_node,
EngineIdToLayerMap* new_layer_map,
ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer);
void LayerScrolled(int engine_layer_id);
scoped_refptr<Layer> GetLayer(int engine_layer_id) const;
DeserializedContentLayerClient* GetContentLayerClient(
int engine_layer_id) const;
int GetClientIdFromEngineId(int engine_layer_id) const;
LayerData* GetLayerData(int engine_layer_id);
std::unique_ptr<LayerFactory> layer_factory_;
LayerTreeHostInProcess* layer_tree_host_;
std::unique_ptr<ClientPictureCache> client_picture_cache_;
CompositorStateDeserializerClient* client_;
EngineIdToLayerMap engine_id_to_layer_;
SyncedPropertyRemote<ScaleGroup> synced_page_scale_;
base::WeakPtrFactory<CompositorStateDeserializer> weak_factory_;
} // namespace cc