cc: Clean up helper function from layer tree host common

cc/trees/layer_tree_host_common.h

 // Copyright 2011 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_TREES_LAYER_TREE_HOST_COMMON_H_
 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
 
 #include <stddef.h>
 
 #include <limits>
@@ skipping 122 matching lines @@
   static void CalculateDrawPropertiesForTesting(
       CalcDrawPropsMainInputsForTesting* inputs);
   static void PreCalculateMetaInformation(Layer* root_layer);
   static void PreCalculateMetaInformationForTesting(LayerImpl* root_layer);
   static void PreCalculateMetaInformationForTesting(Layer* root_layer);
 
   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
   static void CalculateDrawProperties(
       CalcDrawPropsImplInputsForTesting* inputs);
 
-  template <typename LayerType>
-  static bool RenderSurfaceContributesToTarget(LayerType*,
-                                               int target_surface_layer_id);
-
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeHost* layer,
                                         const Function& function,
                                         const CallFunctionLayerType& type);
 
   template <typename Function>
   static void CallFunctionForEveryLayer(LayerTreeImpl* layer,
                                         const Function& function,
                                         const CallFunctionLayerType& type);
 
-  static Layer* get_layer_as_raw_ptr(const LayerList& layers, size_t index) {
-    return layers[index].get();
-  }
-
-  static LayerImpl* get_layer_as_raw_ptr(const LayerImplList& layers,
-                                         size_t index) {
-    return layers[index];
-  }
-
   struct CC_EXPORT ScrollUpdateInfo {
     int layer_id;
     // TODO(miletus): Use ScrollOffset once LayerTreeHost/Blink fully supports
     // franctional scroll offset.
     gfx::Vector2d scroll_delta;
 
     bool operator==(const ScrollUpdateInfo& other) const;
 
     void ToProtobuf(proto::ScrollUpdateInfo* proto) const;
     void FromProtobuf(const proto::ScrollUpdateInfo& proto);
@@ skipping 11 matching lines @@
   std::vector<std::unique_ptr<SwapPromise>> swap_promises;
 
   bool EqualsForTesting(const ScrollAndScaleSet& other) const;
   void ToProtobuf(proto::ScrollAndScaleSet* proto) const;
   void FromProtobuf(const proto::ScrollAndScaleSet& proto);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScrollAndScaleSet);
 };
 
-template <typename LayerType>
-bool LayerTreeHostCommon::RenderSurfaceContributesToTarget(
-    LayerType* layer,
-    int target_surface_layer_id) {
-  // A layer will either contribute its own content, or its render surface's
-  // content, to the target surface. The layer contributes its surface's content
-  // when both the following are true:
-  //  (1) The layer actually has a render surface and rendering into that
-  //      surface, and
-  //  (2) The layer's render surface is not the same as the target surface.
-  //
-  // Otherwise, the layer just contributes itself to the target surface.
-
-  return layer->has_render_surface() &&
-         layer->render_target() == layer->render_surface() &&
-         layer->id() != target_surface_layer_id;
-}
-
 template <typename LayerType, typename Function>
 static void CallFunctionForLayer(LayerType* layer,
                                  const Function& function,
                                  const CallFunctionLayerType& type) {
   function(layer);
 
   LayerType* mask_layer = layer->mask_layer();
   if ((type & CallFunctionLayerType::MASK_LAYER) && mask_layer)
     function(mask_layer);
   LayerType* replica_layer = layer->replica_layer();
@@ skipping 34 matching lines @@
   for (auto* layer : *host_impl)
     CallFunctionForLayer(layer, function, type);
 }
 
 CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer);
 CC_EXPORT PropertyTrees* GetPropertyTrees(LayerImpl* layer);
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_