bpf_dsl: replace scoped_refptr with std::shared_ptr

sandbox/linux/bpf_dsl/cons.h

 // Copyright 2014 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 SANDBOX_LINUX_BPF_DSL_CONS_H_
 #define SANDBOX_LINUX_BPF_DSL_CONS_H_
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/ref_counted.h"
 #include "sandbox/sandbox_export.h"
 
 namespace sandbox {
 namespace cons {
 
 // Namespace cons provides an abstraction for immutable "cons list"
 // data structures as commonly provided in functional programming
 // languages like Lisp or Haskell.
 //
 // A cons list is a linked list consisting of "cells", each of which
@@ skipping 33 matching lines @@
 //   }
 
 // Forward declarations.
 template <typename T>
 class Cell;
 template <typename T>
 class ListIterator;
 
 // List represents a (possibly null) pointer to a cons cell.
 template <typename T>
-using List = scoped_refptr<const Cell<T>>;
+using List = std::shared_ptr<const Cell<T>>;
 
 // Cons extends a cons list by prepending a new value to the front.
 template <typename T>
-List<T> Cons(const T& head, const List<T>& tail) {
-  return List<T>(new const Cell<T>(head, tail));
+List<T> Cons(const T& head, List<T> tail) {
+  return std::make_shared<Cell<T>>(head, std::move(tail));
 }
 
 // Cell represents an individual "cons cell" within a cons list.
 template <typename T>
-class Cell : public base::RefCounted<Cell<T>> {
+class Cell {
  public:
-  Cell(const T& head, const List<T>& tail) : head_(head), tail_(tail) {}
+  Cell(const T& head, List<T> tail) : head_(head), tail_(std::move(tail)) {}
 
   // Head returns this cell's head element.
   const T& head() const { return head_; }
 
   // Tail returns this cell's tail element.
   const List<T>& tail() const { return tail_; }
 
  private:
-  virtual ~Cell() {}
-
   T head_;
   List<T> tail_;
 
-  friend class base::RefCounted<Cell<T>>;
   DISALLOW_COPY_AND_ASSIGN(Cell);
 };
 
 // Begin returns a list iterator pointing to the first element of the
 // cons list. It's provided to support range-based for loops.
 template <typename T>
 ListIterator<T> begin(const List<T>& list) {
   return ListIterator<T>(list);
 }
 
@@ skipping 30 matching lines @@
 
 template <typename T>
 bool operator!=(const ListIterator<T>& lhs, const ListIterator<T>& rhs) {
   return !(lhs == rhs);
 }
 
 }  // namespace cons
 }  // namespace sandbox
 
 #endif  // SANDBOX_LINUX_BPF_DSL_CONS_H_