Reland of Delete rtc::linked_ptr.

webrtc/api/statstypes.h

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 // This file contains structures used for retrieving statistics from an ongoing
 // libjingle session.
 
 #ifndef WEBRTC_API_STATSTYPES_H_
 #define WEBRTC_API_STATSTYPES_H_
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/constructormagic.h"
-#include "webrtc/base/linked_ptr.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/thread_checker.h"
 
 namespace webrtc {
 
 class StatsReport {
  public:
   // Indicates whether a track is for sending or receiving.
@@ skipping 221 matching lines @@
 
     Value(StatsValueName name, int64_t value, Type int_type);
     Value(StatsValueName name, float f);
     Value(StatsValueName name, const std::string& value);
     Value(StatsValueName name, const char* value);
     Value(StatsValueName name, bool b);
     Value(StatsValueName name, const Id& value);
 
     ~Value();
 
+    // Support ref counting. Note that for performance reasons, we
+    // don't use thread safe operations. Therefore, all operations
+    // affecting the ref count (in practice, creation and copying of
+    // the Values mapping) must occur on webrtc's signalling thread.
+    int AddRef() const {
+      RTC_DCHECK_RUN_ON(&thread_checker_);
+      return ++ref_count_;
+    }
+    int Release() const {
+      RTC_DCHECK_RUN_ON(&thread_checker_);
+      int count = --ref_count_;
+      if (!count)
+        delete this;
+      return count;
+    }
+
     // TODO(tommi): This compares name as well as value...
     // I think we should only need to compare the value part and
     // move the name part into a hash map.
     bool Equals(const Value& other) const;
 
     // Comparison operators. Return true iff the current instance is of the
     // correct type and holds the same value.  No conversion is performed so
     // a string value of "123" is not equal to an int value of 123 and an int
     // value of 123 is not equal to a float value of 123.0f.
     // One exception to this is that types kInt and kInt64 can be compared and
@@ skipping 20 matching lines @@
 
     // Converts the native value to a string representation of the value.
     std::string ToString() const;
 
     Type type() const { return type_; }
 
     // TODO(tommi): Move |name| and |display_name| out of the Value struct.
     const StatsValueName name;
 
    private:
+    rtc::ThreadChecker thread_checker_;

[tommi, 2017/01/18 12:48:20]

just fyi, SequenceChecker is also an option and perhaps a better one for future
compatibility.

[nisse-webrtc, 2017/01/18 12:56:21]

Seems a bit tricky to convert this code to use a TaskQueue. The callback to
OnComplete would then be a task, and Chrome would have to post a new task on the
same task queue to delete its copy.

+    mutable int ref_count_ ACCESS_ON(thread_checker_) = 0;
+
     const Type type_;
     // TODO(tommi): Use C++ 11 union and make value_ const.
     union InternalType {
       int int_;
       int64_t int64_;
       float float_;
       bool bool_;
       std::string* string_;
       const char* static_string_;
       Id* id_;
     } value_;
 
-   private:
     RTC_DISALLOW_COPY_AND_ASSIGN(Value);
   };
 
-  // TODO(tommi): Consider using a similar approach to how we store Ids using
-  // scoped_refptr for values.
-  typedef rtc::linked_ptr<Value> ValuePtr;
+  typedef rtc::scoped_refptr<Value> ValuePtr;
   typedef std::map<StatsValueName, ValuePtr> Values;
 
   // Ownership of |id| is passed to |this|.
   explicit StatsReport(const Id& id);
 
   // Factory functions for various types of stats IDs.
   static Id NewBandwidthEstimationId();
   static Id NewTypedId(StatsType type, const std::string& id);
   static Id NewTypedIntId(StatsType type, int id);
   static Id NewIdWithDirection(
@@ skipping 68 matching lines @@
   StatsReport* Find(const StatsReport::Id& id);
 
  private:
   Container list_;
   rtc::ThreadChecker thread_checker_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_STATSTYPES_H_