Revert of List all child surfaces (including occluded) in CompositorFrame (patchset #7 id:120001 of https://codereview.chromium.org/1430363002/ )

Reason for revert:
Seems to have broken resize of some OOPIF.

BUG=560237

Original issue's description:
> List all child surfaces (including occluded) in CompositorFrame
>
> Then any occluded child surface with a copy request can be aggregated
> (and have its copy done) whenever its parent draws.
>
> BUG=529378
> CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
>
> Committed: https://crrev.com/915e16b393182f9ccc0ddc4caadd5f7744b25fd4
> Cr-Commit-Position: refs/heads/master@{#360896}

TBR=danakj@chromium.org,kenrb@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=529378

Review URL: https://codereview.chromium.org/1475643006

Cr-Commit-Position: refs/heads/master@{#361604}

13 files changed, 23 insertions, 212 deletions

diff --git a/cc/layers/surface_layer_impl.cc b/cc/layers/surface_layer_impl.cc
index e0dcadf..546af40 100644
--- a/cc/layers/surface_layer_impl.cc
+++ b/cc/layers/surface_layer_impl.cc
@@ -8,19 +8,15 @@
 #include "cc/debug/debug_colors.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 
 namespace cc {
 
 SurfaceLayerImpl::SurfaceLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id), surface_scale_(0.f) {
-  layer_tree_impl()->AddSurfaceLayer(this);
 }
 
-SurfaceLayerImpl::~SurfaceLayerImpl() {
-  layer_tree_impl()->RemoveSurfaceLayer(this);
-}
+SurfaceLayerImpl::~SurfaceLayerImpl() {}
 
 scoped_ptr<LayerImpl> SurfaceLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
@@ -80,6 +76,7 @@ void SurfaceLayerImpl::AppendQuads(RenderPass* render_pass,
   SurfaceDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect, surface_id_);
+  render_pass->referenced_surfaces.push_back(surface_id_);
 }
 
 void SurfaceLayerImpl::GetDebugBorderProperties(SkColor* color,
diff --git a/cc/layers/surface_layer_impl.h b/cc/layers/surface_layer_impl.h
index 4d2c48b..2bf6a9a 100644
--- a/cc/layers/surface_layer_impl.h
+++ b/cc/layers/surface_layer_impl.h
@@ -22,7 +22,6 @@ class CC_EXPORT SurfaceLayerImpl : public LayerImpl {
   void SetSurfaceId(SurfaceId surface_id);
   void SetSurfaceScale(float scale);
   void SetSurfaceSize(const gfx::Size& size);
-  SurfaceId surface_id() const { return surface_id_; }
 
   // LayerImpl overrides.
   scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
diff --git a/cc/output/compositor_frame_metadata.h b/cc/output/compositor_frame_metadata.h
index 392c6b0..72035e3 100644
--- a/cc/output/compositor_frame_metadata.h
+++ b/cc/output/compositor_frame_metadata.h
@@ -9,7 +9,6 @@
 
 #include "cc/base/cc_export.h"
 #include "cc/output/viewport_selection_bound.h"
-#include "cc/surfaces/surface_id.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/size_f.h"
@@ -58,9 +57,6 @@ class CC_EXPORT CompositorFrameMetadata {
   // A set of SurfaceSequences that this frame satisfies (always in the same
   // namespace as the current Surface).
   std::vector<uint32_t> satisfies_sequences;
-
-  // This is the set of Surfaces that are referenced by this frame.
-  std::vector<SurfaceId> referenced_surfaces;
 };
 
 }  // namespace cc
diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h
index e6cc67a..bc64d74 100644
--- a/cc/quads/render_pass.h
+++ b/cc/quads/render_pass.h
@@ -117,6 +117,10 @@ class CC_EXPORT RenderPass {
   QuadList quad_list;
   SharedQuadStateList shared_quad_state_list;
 
+  // This vector contains the complete set of SurfaceIds referenced by
+  // DrawQuads in quad_list.
+  std::vector<SurfaceId> referenced_surfaces;
+
  protected:
   explicit RenderPass(size_t num_layers);
   RenderPass();
diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc
index 140b7e1..f00c006 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc
@@ -26,6 +26,7 @@ struct RenderPassSize {
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
   bool has_transparent_background;
+  std::vector<SurfaceId> referenced_surfaces;
   std::vector<scoped_ptr<CopyOutputRequest>> copy_callbacks;
 };
 
@@ -47,6 +48,7 @@ static void CompareRenderPassLists(const RenderPassList& expected_list,
     EXPECT_EQ(expected->shared_quad_state_list.size(),
               actual->shared_quad_state_list.size());
     EXPECT_EQ(expected->quad_list.size(), actual->quad_list.size());
+    EXPECT_EQ(expected->referenced_surfaces, actual->referenced_surfaces);
 
     for (auto exp_iter = expected->quad_list.cbegin(),
               act_iter = actual->quad_list.cbegin();
@@ -100,6 +102,7 @@ TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) {
   EXPECT_EQ(pass->damage_rect, copy->damage_rect);
   EXPECT_EQ(pass->has_transparent_background, copy->has_transparent_background);
   EXPECT_EQ(0u, copy->quad_list.size());
+  EXPECT_EQ(0u, copy->referenced_surfaces.size());
 
   // The copy request should not be copied/duplicated.
   EXPECT_EQ(1u, pass->copy_requests.size());
diff --git a/cc/surfaces/surface.cc b/cc/surfaces/surface.cc
index 563415c..8faff98 100644
--- a/cc/surfaces/surface.cc
+++ b/cc/surfaces/surface.cc
@@ -66,7 +66,12 @@ void Surface::QueueFrame(scoped_ptr<CompositorFrame> frame,
 
   std::vector<SurfaceId> new_referenced_surfaces;
   if (current_frame_) {
-    new_referenced_surfaces = current_frame_->metadata.referenced_surfaces;
+    for (auto& render_pass :
+         current_frame_->delegated_frame_data->render_pass_list) {
+      new_referenced_surfaces.insert(new_referenced_surfaces.end(),
+                                     render_pass->referenced_surfaces.begin(),
+                                     render_pass->referenced_surfaces.end());
+    }
   }
 
   if (previous_frame) {
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 181b07f..4c1441a 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -58,10 +58,6 @@ SurfaceAggregator::~SurfaceAggregator() {
   ProcessAddedAndRemovedSurfaces();
 }
 
-SurfaceAggregator::PrewalkResult::PrewalkResult() {}
-
-SurfaceAggregator::PrewalkResult::~PrewalkResult() {}
-
 // Create a clip rect for an aggregated quad from the original clip rect and
 // the clip rect from the surface it's on.
 SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
@@ -495,8 +491,7 @@ void SurfaceAggregator::ProcessAddedAndRemovedSurfaces() {
 // Walk the Surface tree from surface_id. Validate the resources of the current
 // surface and its descendants, check if there are any copy requests, and
 // return the combined damage rect.
-gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id,
-                                         PrewalkResult* result) {
+gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id) {
   if (referenced_surfaces_.count(surface_id))
     return gfx::Rect();
   Surface* surface = manager_->GetSurfaceForId(surface_id);
@@ -574,7 +569,7 @@ gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id,
     provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
 
   for (const auto& render_pass : frame_data->render_pass_list)
-    result->has_copy_requests |= !render_pass->copy_requests.empty();
+    has_copy_requests_ |= !render_pass->copy_requests.empty();
 
   gfx::Rect damage_rect;
   if (!frame_data->render_pass_list.empty()) {
@@ -588,63 +583,14 @@ gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id,
   SurfaceSet::iterator it =
       referenced_surfaces_.insert(surface->surface_id()).first;
   for (const auto& surface_info : child_surfaces) {
-    gfx::Rect surface_damage = PrewalkTree(surface_info.first, result);
+    gfx::Rect surface_damage = PrewalkTree(surface_info.first);
     damage_rect.Union(
         MathUtil::MapEnclosingClippedRect(surface_info.second, surface_damage));
   }
-
-  for (const auto& surface_id : surface_frame->metadata.referenced_surfaces) {
-    if (!contained_surfaces_.count(surface_id)) {
-      result->undrawn_surfaces.insert(surface_id);
-      PrewalkTree(surface_id, result);
-    }
-  }
-
   referenced_surfaces_.erase(it);
   return damage_rect;
 }
 
-void SurfaceAggregator::CopyUndrawnSurfaces(PrewalkResult* prewalk_result) {
-  // undrawn_surfaces are Surfaces that were identified by prewalk as being
-  // referenced by a drawn Surface, but aren't contained in a SurfaceDrawQuad.
-  // They need to be iterated over to ensure that any copy requests on them
-  // (or on Surfaces they reference) are executed.
-  std::vector<SurfaceId> surfaces_to_copy(
-      prewalk_result->undrawn_surfaces.begin(),
-      prewalk_result->undrawn_surfaces.end());
-
-  for (size_t i = 0; i < surfaces_to_copy.size(); i++) {
-    SurfaceId surface_id = surfaces_to_copy[i];
-    Surface* surface = manager_->GetSurfaceForId(surface_id);
-    const CompositorFrame* surface_frame = surface->GetEligibleFrame();
-    if (!surface_frame)
-      continue;
-    bool surface_has_copy_requests = false;
-    for (const auto& render_pass :
-         surface_frame->delegated_frame_data->render_pass_list) {
-      surface_has_copy_requests |= !render_pass->copy_requests.empty();
-    }
-    if (!surface_has_copy_requests) {
-      // Children are not necessarily included in undrawn_surfaces (because
-      // they weren't referenced directly from a drawn surface), but may have
-      // copy requests, so make sure to check them as well.
-      for (const auto& child_id : surface_frame->metadata.referenced_surfaces) {
-        // Don't iterate over the child Surface if it was already listed as a
-        // child of a different Surface, or in the case where there's infinite
-        // recursion.
-        if (!prewalk_result->undrawn_surfaces.count(child_id)) {
-          surfaces_to_copy.push_back(child_id);
-          prewalk_result->undrawn_surfaces.insert(child_id);
-        }
-      }
-    } else {
-      SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
-      CopyPasses(surface_frame->delegated_frame_data.get(), surface);
-      referenced_surfaces_.erase(it);
-    }
-  }
-}
-
 scoped_ptr<CompositorFrame> SurfaceAggregator::Aggregate(SurfaceId surface_id) {
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   DCHECK(surface);
@@ -663,11 +609,9 @@ scoped_ptr<CompositorFrame> SurfaceAggregator::Aggregate(SurfaceId surface_id) {
   dest_pass_list_ = &frame->delegated_frame_data->render_pass_list;
 
   valid_surfaces_.clear();
-  PrewalkResult prewalk_result;
-  root_damage_rect_ = PrewalkTree(surface_id, &prewalk_result);
-  has_copy_requests_ = prewalk_result.has_copy_requests;
+  has_copy_requests_ = false;
+  root_damage_rect_ = PrewalkTree(surface_id);
 
-  CopyUndrawnSurfaces(&prewalk_result);
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
   CopyPasses(root_surface_frame->delegated_frame_data.get(), surface);
   referenced_surfaces_.erase(it);
diff --git a/cc/surfaces/surface_aggregator.h b/cc/surfaces/surface_aggregator.h
index 6df7e6b..738aeec 100644
--- a/cc/surfaces/surface_aggregator.h
+++ b/cc/surfaces/surface_aggregator.h
@@ -60,15 +60,6 @@ class CC_SURFACES_EXPORT SurfaceAggregator {
     gfx::Rect rect;
   };
 
-  struct PrewalkResult {
-    PrewalkResult();
-    ~PrewalkResult();
-    bool has_copy_requests = false;
-    // This is the set of Surfaces that were referenced by another Surface, but
-    // not included in a SurfaceDrawQuad.
-    std::set<SurfaceId> undrawn_surfaces;
-  };
-
   ClipData CalculateClipRect(const ClipData& surface_clip,
                              const ClipData& quad_clip,
                              const gfx::Transform& target_transform);
@@ -92,8 +83,7 @@ class CC_SURFACES_EXPORT SurfaceAggregator {
       const ClipData& clip_rect,
       RenderPass* dest_pass,
       SurfaceId surface_id);
-  gfx::Rect PrewalkTree(SurfaceId surface_id, PrewalkResult* result);
-  void CopyUndrawnSurfaces(PrewalkResult* prewalk);
+  gfx::Rect PrewalkTree(SurfaceId surface_id);
   void CopyPasses(const DelegatedFrameData* frame_data, Surface* surface);
 
   // Remove Surfaces that were referenced before but aren't currently
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 86eedf6..53b01e0 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -477,108 +477,6 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
   factory_.Destroy(embedded_surface_id);
 }
 
-TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {
-  SurfaceId embedded_surface_id = allocator_.GenerateId();
-  factory_.Create(embedded_surface_id);
-  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
-  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
-
-  test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
-  test::Pass embedded_passes[] = {
-      test::Pass(embedded_quads, arraysize(embedded_quads))};
-
-  SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
-                        embedded_surface_id);
-  scoped_ptr<CopyOutputRequest> copy_request(
-      CopyOutputRequest::CreateEmptyRequest());
-  CopyOutputRequest* copy_request_ptr = copy_request.get();
-  factory_.RequestCopyOfSurface(embedded_surface_id, copy_request.Pass());
-
-  SurfaceId parent_surface_id = allocator_.GenerateId();
-  factory_.Create(parent_surface_id);
-  Surface* parent_surface = manager_.GetSurfaceForId(parent_surface_id);
-
-  test::Quad parent_quads[] = {
-      test::Quad::SolidColorQuad(SK_ColorWHITE),
-      test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
-      test::Quad::SolidColorQuad(SK_ColorBLACK)};
-  test::Pass parent_passes[] = {
-      test::Pass(parent_quads, arraysize(parent_quads))};
-
-  {
-    scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
-    AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
-              parent_passes, arraysize(parent_passes));
-
-    scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->delegated_frame_data = frame_data.Pass();
-    frame->metadata.referenced_surfaces.push_back(embedded_surface_id);
-
-    factory_.SubmitCompositorFrame(parent_surface_id, frame.Pass(),
-                                   SurfaceFactory::DrawCallback());
-  }
-
-  test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
-                             test::Quad::SolidColorQuad(SK_ColorBLACK)};
-  test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
-
-  {
-    scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
-    AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
-              root_passes, arraysize(root_passes));
-
-    scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->delegated_frame_data = frame_data.Pass();
-    frame->metadata.referenced_surfaces.push_back(parent_surface_id);
-
-    factory_.SubmitCompositorFrame(root_surface_id_, frame.Pass(),
-                                   SurfaceFactory::DrawCallback());
-  }
-
-  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
-  EXPECT_FALSE(surface_aggregator_client_.HasSurface(parent_surface));
-  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
-
-  scoped_ptr<CompositorFrame> aggregated_frame =
-      aggregator_.Aggregate(root_surface_id_);
-
-  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
-  EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
-  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
-
-  ASSERT_TRUE(aggregated_frame);
-  ASSERT_TRUE(aggregated_frame->delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
-
-  // First pass should come from surface that had a copy request but was not
-  // referenced directly. The second pass comes from the root surface.
-  // parent_quad should be ignored because it is neither referenced through a
-  // SurfaceDrawQuad nor has a copy request on it.
-  test::Pass expected_passes[] = {
-      test::Pass(embedded_quads, arraysize(embedded_quads)),
-      test::Pass(root_quads, arraysize(root_quads))};
-  TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),
-                              &frame_data->render_pass_list);
-  ASSERT_EQ(2u, frame_data->render_pass_list.size());
-  ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
-  DCHECK_EQ(copy_request_ptr,
-            frame_data->render_pass_list[0]->copy_requests[0].get());
-
-  SurfaceId surface_ids[] = {root_surface_id_, parent_surface_id,
-                             embedded_surface_id};
-  EXPECT_EQ(arraysize(surface_ids),
-            aggregator_.previous_contained_surfaces().size());
-  for (size_t i = 0; i < arraysize(surface_ids); i++) {
-    EXPECT_TRUE(
-        aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
-        aggregator_.previous_contained_surfaces().end());
-  }
-
-  factory_.Destroy(parent_surface_id);
-  factory_.Destroy(embedded_surface_id);
-}
-
 // This tests referencing a surface that has multiple render passes.
 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {
   SurfaceId embedded_surface_id = child_allocator_.GenerateId();
diff --git a/cc/surfaces/surface_factory_unittest.cc b/cc/surfaces/surface_factory_unittest.cc
index 749d7c5..fa05c2e 100644
--- a/cc/surfaces/surface_factory_unittest.cc
+++ b/cc/surfaces/surface_factory_unittest.cc
@@ -490,10 +490,10 @@ TEST_F(SurfaceFactoryTest, DestroyCycle) {
   // Give id2 a frame that references surface_id_.
   {
     scoped_ptr<RenderPass> render_pass(RenderPass::Create());
+    render_pass->referenced_surfaces.push_back(surface_id_);
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     frame_data->render_pass_list.push_back(std::move(render_pass));
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->metadata.referenced_surfaces.push_back(surface_id_);
     frame->delegated_frame_data = std::move(frame_data);
     factory_->SubmitCompositorFrame(id2, std::move(frame),
                                     SurfaceFactory::DrawCallback());
@@ -503,10 +503,10 @@ TEST_F(SurfaceFactoryTest, DestroyCycle) {
   // Give surface_id_ a frame that references id2.
   {
     scoped_ptr<RenderPass> render_pass(RenderPass::Create());
+    render_pass->referenced_surfaces.push_back(id2);
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     frame_data->render_pass_list.push_back(std::move(render_pass));
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->metadata.referenced_surfaces.push_back(id2);
     frame->delegated_frame_data = std::move(frame_data);
     factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
                                     SurfaceFactory::DrawCallback());
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 042365b..12071a7 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -43,7 +43,6 @@
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl_base.h"
-#include "cc/layers/surface_layer_impl.h"
 #include "cc/layers/viewport.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
@@ -1563,10 +1562,6 @@ CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
         !OuterViewportScrollLayer()->user_scrollable_vertical();
   }
 
-  for (LayerImpl* surface_layer : active_tree_->SurfaceLayers()) {
-    metadata.referenced_surfaces.push_back(
-        static_cast<SurfaceLayerImpl*>(surface_layer)->surface_id());
-  }
   if (!InnerViewportScrollLayer())
     return metadata;
 
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 06635e5..5964760 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1319,19 +1319,6 @@ void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl* layer) {
   }
 }
 
-void LayerTreeImpl::AddSurfaceLayer(LayerImpl* layer) {
-  DCHECK(std::find(surface_layers_.begin(), surface_layers_.end(), layer) ==
-         surface_layers_.end());
-  surface_layers_.push_back(layer);
-}
-
-void LayerTreeImpl::RemoveSurfaceLayer(LayerImpl* layer) {
-  std::vector<LayerImpl*>::iterator it =
-      std::find(surface_layers_.begin(), surface_layers_.end(), layer);
-  DCHECK(it != surface_layers_.end());
-  surface_layers_.erase(it);
-}
-
 const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest()
     const {
   // Only the active tree needs to know about layers with copy requests, as
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index bbea5d7..2f8fbfc7 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -333,12 +333,6 @@ class CC_EXPORT LayerTreeImpl {
   void RemoveLayerWithCopyOutputRequest(LayerImpl* layer);
   const std::vector<LayerImpl*>& LayersWithCopyOutputRequest() const;
 
-  void AddSurfaceLayer(LayerImpl* layer);
-  void RemoveSurfaceLayer(LayerImpl* layer);
-  const std::vector<LayerImpl*>& SurfaceLayers() const {
-    return surface_layers_;
-  }
-
   int current_render_surface_list_id() const {
     return render_surface_layer_list_id_;
   }
@@ -469,7 +463,6 @@ class CC_EXPORT LayerTreeImpl {
 
   std::vector<PictureLayerImpl*> picture_layers_;
   std::vector<LayerImpl*> layers_with_copy_output_request_;
-  std::vector<LayerImpl*> surface_layers_;
 
   // List of visible layers for the most recently prepared frame.
   LayerImplList render_surface_layer_list_;