// 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.

#ifndef CC_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_
#define CC_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_

#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 {
 public:
  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 {
 public:
  CompositorStateDeserializer(
      LayerTreeHostInProcess* layer_tree_host,
      std::unique_ptr<ClientPictureCache> client_picture_cache,
      CompositorStateDeserializerClient* client);
  ~CompositorStateDeserializer();

  // 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();

 private:
  using SyncedRemoteScrollOffset =
      SyncedPropertyRemote<AdditionGroup<gfx::ScrollOffset>>;

  // A holder for the Layer and any data tied to it.
  struct LayerData {
    LayerData();
    LayerData(LayerData&& other);
    ~LayerData();

    LayerData& operator=(LayerData&& other);

    scoped_refptr<Layer> layer;

    // Set only for PictureLayers.
    std::unique_ptr<DeserializedContentLayerClient> content_layer_client;

    SyncedRemoteScrollOffset synced_scroll_offset;

   private:
    DISALLOW_COPY_AND_ASSIGN(LayerData);
  };

  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_;

  DISALLOW_COPY_AND_ASSIGN(CompositorStateDeserializer);
};

}  // namespace cc

#endif  // CC_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_