// 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/test/serialization_test_utils.h"

#include "cc/blimp/compositor_state_deserializer.h"
#include "cc/layers/layer.h"
#include "cc/layers/solid_color_scrollbar_layer.h"
#include "cc/test/fake_picture_layer.h"
#include "cc/test/skia_common.h"
#include "cc/trees/layer_tree.h"
#include "cc/trees/layer_tree_host_common.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace cc {

#define EXPECT_LAYERS_EQ(engine_layer_id, client_layer)                    \
  EXPECT_EQ(                                                               \
      compositor_state_deserializer->GetLayerForEngineId(engine_layer_id), \
      client_layer);

void VerifySerializedTreesAreIdentical(
    LayerTree* engine_layer_tree,
    LayerTree* client_layer_tree,
    CompositorStateDeserializer* compositor_state_deserializer) {
  if (engine_layer_tree->root_layer()) {
    for (auto* engine_layer : *engine_layer_tree) {
      Layer* client_layer = compositor_state_deserializer->GetLayerForEngineId(
          engine_layer->id());
      EXPECT_EQ(client_layer->GetLayerTree(), client_layer_tree);
      VerifySerializedLayersAreIdentical(engine_layer,
                                         compositor_state_deserializer);
    }
  } else {
    EXPECT_EQ(client_layer_tree->root_layer(), nullptr);
  }

  // Viewport layers.
  // Overscroll Elasticty Layer.
  Layer* client_overscroll_elasticity_layer =
      client_layer_tree->overscroll_elasticity_layer();
  if (engine_layer_tree->overscroll_elasticity_layer()) {
    int engine_overscroll_elasticity_layer_id =
        engine_layer_tree->overscroll_elasticity_layer()->id();

    EXPECT_LAYERS_EQ(engine_overscroll_elasticity_layer_id,
                     client_overscroll_elasticity_layer);
  } else {
    EXPECT_EQ(client_overscroll_elasticity_layer, nullptr);
  }

  // PageScale Layer.
  Layer* client_page_scale_layer = client_layer_tree->page_scale_layer();
  if (engine_layer_tree->page_scale_layer()) {
    int engine_page_scale_layer_id =
        engine_layer_tree->page_scale_layer()->id();

    EXPECT_LAYERS_EQ(engine_page_scale_layer_id, client_page_scale_layer);
  } else {
    EXPECT_EQ(client_page_scale_layer, nullptr);
  }

  // InnerViewportScroll Layer.
  Layer* client_inner_viewport_layer =
      client_layer_tree->inner_viewport_scroll_layer();
  if (engine_layer_tree->inner_viewport_scroll_layer()) {
    int engine_inner_viewport_layer_id =
        engine_layer_tree->inner_viewport_scroll_layer()->id();

    EXPECT_LAYERS_EQ(engine_inner_viewport_layer_id,
                     client_inner_viewport_layer);
  } else {
    EXPECT_EQ(client_inner_viewport_layer, nullptr);
  }

  // OuterViewportScroll Layer.
  Layer* client_outer_viewport_layer =
      client_layer_tree->outer_viewport_scroll_layer();
  if (engine_layer_tree->outer_viewport_scroll_layer()) {
    int engine_outer_viewport_layer_id =
        engine_layer_tree->outer_viewport_scroll_layer()->id();

    EXPECT_LAYERS_EQ(engine_outer_viewport_layer_id,
                     client_outer_viewport_layer);
  } else {
    EXPECT_EQ(client_outer_viewport_layer, nullptr);
  }

  // Other LayerTree inputs.
  EXPECT_EQ(engine_layer_tree->device_scale_factor(),
            client_layer_tree->device_scale_factor());
  EXPECT_EQ(engine_layer_tree->painted_device_scale_factor(),
            client_layer_tree->painted_device_scale_factor());
  EXPECT_EQ(engine_layer_tree->device_viewport_size(),
            client_layer_tree->device_viewport_size());

  EXPECT_EQ(engine_layer_tree->page_scale_factor(),
            client_layer_tree->page_scale_factor());
  EXPECT_EQ(engine_layer_tree->min_page_scale_factor(),
            client_layer_tree->min_page_scale_factor());
  EXPECT_EQ(engine_layer_tree->max_page_scale_factor(),
            client_layer_tree->max_page_scale_factor());

  EXPECT_EQ(engine_layer_tree->background_color(),
            client_layer_tree->background_color());
  EXPECT_EQ(engine_layer_tree->has_transparent_background(),
            client_layer_tree->has_transparent_background());

  EXPECT_EQ(engine_layer_tree->selection(), client_layer_tree->selection());

  EXPECT_EQ(engine_layer_tree->have_scroll_event_handlers(),
            client_layer_tree->have_scroll_event_handlers());

  for (int i = 0; i < static_cast<int>(EventListenerClass::kNumClasses); ++i) {
    EXPECT_EQ(engine_layer_tree->event_listener_properties(
                  static_cast<EventListenerClass>(i)),
              client_layer_tree->event_listener_properties(
                  static_cast<EventListenerClass>(i)));
  }
}

void VerifySerializedLayersAreIdentical(
    Layer* engine_layer,
    CompositorStateDeserializer* compositor_state_deserializer) {
  Layer* client_layer =
      compositor_state_deserializer->GetLayerForEngineId(engine_layer->id());
  if (engine_layer == nullptr) {
    EXPECT_EQ(client_layer, nullptr);
    return;
  }

  // Parent.
  if (engine_layer->parent()) {
    int engine_parent_id = engine_layer->parent()->id();
    EXPECT_LAYERS_EQ(engine_parent_id, client_layer->parent());
  } else {
    EXPECT_EQ(client_layer->parent(), nullptr);
  }

  // Mask Layers.
  if (engine_layer->mask_layer()) {
    int engine_mask_layer_id = engine_layer->mask_layer()->id();
    EXPECT_LAYERS_EQ(engine_mask_layer_id, client_layer->mask_layer());
  } else {
    EXPECT_EQ(client_layer->mask_layer(), nullptr);
  }

  // Scroll parent.
  if (engine_layer->scroll_parent()) {
    int engine_scroll_parent_id = engine_layer->scroll_parent()->id();
    EXPECT_LAYERS_EQ(engine_scroll_parent_id, client_layer->scroll_parent());
  } else {
    EXPECT_EQ(client_layer->scroll_parent(), nullptr);
  }

  // Clip parent.
  if (engine_layer->clip_parent()) {
    int engine_clip_parent_id = engine_layer->clip_parent()->id();
    EXPECT_LAYERS_EQ(engine_clip_parent_id, client_layer->clip_parent());
  } else {
    EXPECT_EQ(client_layer->clip_parent(), nullptr);
  }

  // Scroll-clip layer.
  if (engine_layer->scroll_clip_layer()) {
    int scroll_clip_id = engine_layer->scroll_clip_layer()->id();
    EXPECT_LAYERS_EQ(scroll_clip_id, client_layer->scroll_clip_layer());
  } else {
    EXPECT_EQ(client_layer->scroll_clip_layer(), nullptr);
  }

  // Other Layer properties.
  // Note: The update rect is ignored here since it is cleared during
  // serialization.
  EXPECT_EQ(engine_layer->transform_origin(), client_layer->transform_origin());
  EXPECT_EQ(engine_layer->background_color(), client_layer->background_color());
  EXPECT_EQ(engine_layer->bounds(), client_layer->bounds());
  EXPECT_EQ(engine_layer->double_sided(), client_layer->double_sided());
  EXPECT_EQ(engine_layer->hide_layer_and_subtree(),
            client_layer->hide_layer_and_subtree());
  EXPECT_EQ(engine_layer->masks_to_bounds(), client_layer->masks_to_bounds());
  EXPECT_EQ(engine_layer->main_thread_scrolling_reasons(),
            client_layer->main_thread_scrolling_reasons());
  EXPECT_EQ(engine_layer->non_fast_scrollable_region(),
            client_layer->non_fast_scrollable_region());
  EXPECT_EQ(engine_layer->touch_event_handler_region(),
            client_layer->touch_event_handler_region());
  EXPECT_EQ(engine_layer->contents_opaque(), client_layer->contents_opaque());
  EXPECT_EQ(engine_layer->opacity(), client_layer->opacity());
  EXPECT_EQ(engine_layer->blend_mode(), client_layer->blend_mode());
  EXPECT_EQ(engine_layer->is_root_for_isolated_group(),
            client_layer->is_root_for_isolated_group());
  EXPECT_EQ(engine_layer->position(), client_layer->position());
  EXPECT_EQ(engine_layer->IsContainerForFixedPositionLayers(),
            client_layer->IsContainerForFixedPositionLayers());
  EXPECT_EQ(engine_layer->position_constraint(),
            client_layer->position_constraint());
  EXPECT_EQ(engine_layer->should_flatten_transform(),
            client_layer->should_flatten_transform());
  EXPECT_EQ(engine_layer->use_parent_backface_visibility(),
            client_layer->use_parent_backface_visibility());
  EXPECT_EQ(engine_layer->transform(), client_layer->transform());
  EXPECT_EQ(engine_layer->sorting_context_id(),
            client_layer->sorting_context_id());
  EXPECT_EQ(engine_layer->user_scrollable_horizontal(),
            client_layer->user_scrollable_horizontal());
  EXPECT_EQ(engine_layer->user_scrollable_vertical(),
            client_layer->user_scrollable_vertical());
  EXPECT_EQ(engine_layer->scroll_offset(), client_layer->scroll_offset());
}

void VerifySerializedScrollbarLayersAreIdentical(
    SolidColorScrollbarLayer* engine_layer,
    CompositorStateDeserializer* compositor_state_deserializer) {
  SolidColorScrollbarLayer* client_layer =
      static_cast<SolidColorScrollbarLayer*>(
          compositor_state_deserializer->GetLayerForEngineId(
              engine_layer->id()));

  if (engine_layer == nullptr) {
    EXPECT_EQ(client_layer, nullptr);
    return;
  }

  EXPECT_LAYERS_EQ(
      engine_layer->ScrollLayerId(),
      client_layer->GetLayerTree()->LayerById(client_layer->ScrollLayerId()));
  EXPECT_EQ(engine_layer->orientation(), client_layer->orientation());
  EXPECT_EQ(engine_layer->thumb_thickness(), client_layer->thumb_thickness());
  EXPECT_EQ(engine_layer->track_start(), client_layer->track_start());
  EXPECT_EQ(engine_layer->is_left_side_vertical_scrollbar(),
            client_layer->is_left_side_vertical_scrollbar());
}

void VerifySerializedPictureLayersAreIdentical(
    FakePictureLayer* engine_layer,
    CompositorStateDeserializer* compositor_state_deserializer) {
  FakePictureLayer* client_layer = static_cast<FakePictureLayer*>(
      compositor_state_deserializer->GetLayerForEngineId(engine_layer->id()));
  EXPECT_EQ(engine_layer->nearest_neighbor(), client_layer->nearest_neighbor());

  RecordingSource* engine_source = engine_layer->GetRecordingSourceForTesting();
  RecordingSource* client_source = client_layer->GetRecordingSourceForTesting();
  EXPECT_EQ(engine_source->recorded_viewport(),
            client_source->recorded_viewport());
  if (engine_source->GetDisplayItemList()) {
    EXPECT_TRUE(AreDisplayListDrawingResultsSame(
        engine_source->recorded_viewport(), engine_source->GetDisplayItemList(),
        client_source->GetDisplayItemList()));
  } else {
    EXPECT_EQ(client_source->GetDisplayItemList(), nullptr);
  }
}

}  // namespace cc