// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CC_TREES_COMMIT_STATE_H_
#define CC_TREES_COMMIT_STATE_H_

#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>

#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/memory/raw_ptr.h"
#include "base/time/time.h"
#include "cc/benchmarks/micro_benchmark_impl.h"
#include "cc/cc_export.h"
#include "cc/debug/layer_tree_debug_state.h"
#include "cc/input/event_listener_properties.h"
#include "cc/input/layer_selection_bound.h"
#include "cc/input/overscroll_behavior.h"
#include "cc/input/page_scale_animation.h"
#include "cc/layers/layer.h"
#include "cc/layers/layer_list_iterator.h"
#include "cc/metrics/begin_main_frame_metrics.h"
#include "cc/metrics/event_metrics.h"
#include "cc/paint/paint_image.h"
#include "cc/resources/ui_resource_request.h"
#include "cc/trees/browser_controls_params.h"
#include "cc/trees/presentation_time_callback_buffer.h"
#include "cc/trees/swap_promise.h"
#include "cc/trees/viewport_property_ids.h"
#include "cc/view_transition/view_transition_request.h"
#include "components/viz/common/surfaces/local_surface_id.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/delegated_ink_metadata.h"
#include "ui/gfx/display_color_spaces.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/vector2d_f.h"
#include "ui/gfx/overlay_transform.h"

namespace cc {
static constexpr int kInvalidSourceFrameNumber = -1;

// CommitState and ThreadUnsafeCommitState contain all of the information from
// LayerTreeHost that is needed to run compositor commit. CommitState is
// effectively POD; the compositor gets its own copy, which it may read or write
// without any concurrency issues.  ThreadUnsafeCommitState is shared data that
// is *not* copied to the compositor. Main thread code must take care not to
// modify anything reachable from ThreadUnsafeCommitState while commit is
// running on the impl thread, typically by adding calls to
// LayerTreeHost::WaitForCommitCompletion() before attempting to mutate state.

struct CC_EXPORT CommitState {
  CommitState();
  // Note: the copy constructor only copies persistent fields
  CommitState(const CommitState&);
  CommitState& operator=(const CommitState&) = delete;
  ~CommitState();

  base::flat_set<viz::SurfaceRange> SurfaceRanges() const;
  EventListenerProperties GetEventListenerProperties(EventListenerClass) const;

  // -------------------------------------------------------------------------
  // Persistent: these values persist on the LayerTreeHost between commits.
  // When a new persistent field is added, it must also be added to the copy
  // constructor.

  base::flat_map<viz::SurfaceRange, int> surface_ranges;
  base::TimeDelta visual_properties_update_duration;
  bool needs_gpu_rasterization_histogram = false;
  bool have_scroll_event_handlers = false;
  bool is_external_pinch_gesture_active = false;
  // Set to true if viewport is mobile optimized by using meta tag
  // <meta name="viewport" content="width=device-width">
  // or
  // <meta name="viewport" content="initial-scale=1.0">
  bool is_viewport_mobile_optimized = false;
  bool may_throttle_if_undrawn_frames = true;
  bool prefers_reduced_motion = false;
  BrowserControlsParams browser_controls_params;
  EventListenerProperties
      event_listener_properties[static_cast<size_t>(EventListenerClass::kLast) +
                                1] = {EventListenerProperties::kNone};
  float bottom_controls_shown_ratio = 0.f;
  float device_scale_factor = 1.f;
  float external_page_scale_factor = 1.f;
  float max_page_scale_factor = 1.f;
  float min_page_scale_factor = 1.f;
  float page_scale_factor = 1.f;
  float painted_device_scale_factor = 1.f;
  float top_controls_shown_ratio = 0.f;
  gfx::DisplayColorSpaces display_color_spaces;
  // Display transform hint to tag generated compositor frames.
  gfx::OverlayTransform display_transform_hint = gfx::OVERLAY_TRANSFORM_NONE;
  gfx::Rect device_viewport_rect;
  gfx::Size visual_device_viewport_size;
  gfx::Vector2dF elastic_overscroll;
  int hud_layer_id = Layer::INVALID_ID;
  int source_frame_number = 0;
  LayerSelection selection;
  LayerTreeDebugState debug_state;
  OverscrollBehavior overscroll_behavior;
  SkColor4f background_color = SkColors::kWhite;
  ViewportPropertyIds viewport_property_ids;
  viz::LocalSurfaceId local_surface_id_from_parent;

  // -------------------------------------------------------------------------
  // Take/reset: these values are reset on the LayerTreeHost between commits.

  // The number of SurfaceLayers that have (fallback,primary) set to
  // viz::SurfaceRange.
  bool clear_caches_on_next_commit = false;
  // Whether we have a pending request to force send RenderFrameMetadata with
  // the next frame.
  bool force_send_metadata_request = false;
  bool commit_waits_for_activation = false;
  bool needs_full_tree_sync = false;
  bool needs_surface_ranges_sync = false;
  bool new_local_surface_id_request = false;
  bool next_commit_forces_recalculate_raster_scales = false;
  bool next_commit_forces_redraw = false;
  uint64_t trace_id = 0;
  EventMetrics::List event_metrics;

  // Latency information for work done in ProxyMain::BeginMainFrame. The
  // unique_ptr is allocated in RequestMainFrameUpdate, and passed to Blink's
  // LocalFrameView that fills in the fields. This object adds the timing for
  // UpdateLayers. CC reads the data during commit, and clears the unique_ptr.
  std::unique_ptr<BeginMainFrameMetrics> begin_main_frame_metrics;

  // Metadata required for drawing a delegated ink trail onto the end of a
  // stroke. std::unique_ptr was specifically chosen so that it would be
  // cleared as it is forwarded along the pipeline to avoid old information
  // incorrectly sticking around and potentially being reused.
  std::unique_ptr<gfx::DelegatedInkMetadata> delegated_ink_metadata;

  std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation;
  std::vector<std::pair<int, std::unique_ptr<PaintImage>>> queued_image_decodes;

  // Presentation time callbacks requested for the next frame are initially
  // added here.
  std::vector<PresentationTimeCallbackBuffer::Callback>
      pending_presentation_callbacks;
  std::vector<PresentationTimeCallbackBuffer::SuccessfulCallback>
      pending_successful_presentation_callbacks;

  std::vector<std::unique_ptr<MicroBenchmarkImpl>> benchmarks;

  // A list of view transitions that need to be transported from Blink to
  // Viz, as a CompositorFrameTransitionDirective.
  std::vector<std::unique_ptr<ViewTransitionRequest>> view_transition_requests;

  std::vector<std::unique_ptr<SwapPromise>> swap_promises;
  std::vector<UIResourceRequest> ui_resource_request_queue;
  base::flat_map<UIResourceId, gfx::Size> ui_resource_sizes;
  PropertyTreesChangeState property_trees_change_state;
  base::flat_set<Layer*> layers_that_should_push_properties;
};

struct CC_EXPORT ThreadUnsafeCommitState {
  ThreadUnsafeCommitState(MutatorHost* mh,
                          const ProtectedSequenceSynchronizer& synchronizer);
  ~ThreadUnsafeCommitState();

  // TODO(szager/vmpstr): These methods are to support range-based 'for' loops,
  // which is weird because ThreadUnsafeCommitState is not a collection or
  // container. We should do something more sensible and less weird.
  LayerListConstIterator begin() const {
    return LayerListConstIterator(root_layer.get());
  }
  LayerListConstIterator end() const { return LayerListConstIterator(nullptr); }

  raw_ptr<MutatorHost> mutator_host;
  PropertyTrees property_trees;
  scoped_refptr<Layer> root_layer;
};

struct CC_EXPORT CommitTimestamps {
  // Time when the compositor first became aware that a commit was requested by
  // the main thread.
  base::TimeTicks start;
  // Time when the compositor finished the commit.
  base::TimeTicks finish;
};

}  // namespace cc

#endif  // CC_TREES_COMMIT_STATE_H_