cc: Remove all blimp code from cc.

cc/test/serialization_test_utils.cc

Index: cc/test/serialization_test_utils.cc
diff --git a/cc/test/serialization_test_utils.cc b/cc/test/serialization_test_utils.cc
deleted file mode 100644
index c9a868a50dac5a9bdf4118f6545868ba3989617e..0000000000000000000000000000000000000000
--- a/cc/test/serialization_test_utils.cc
+++ /dev/null
@@ -1,256 +0,0 @@
-// 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