rtc::Buffer: Let SetData and AppendData accept anything with .data() and .size()

webrtc/base/buffer.h

 /*
  *  Copyright 2004 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.
  */
 
 #ifndef WEBRTC_BASE_BUFFER_H_
 #define WEBRTC_BASE_BUFFER_H_
 
 #include <algorithm>
 #include <cstring>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/type_traits.h"
 
 namespace rtc {
 
 namespace internal {
 
 // (Internal; please don't use outside this file.) Determines if elements of
 // type U are compatible with a BufferT<T>. For most types, we just ignore
 // top-level const and forbid top-level volatile and require T and U to be
 // otherwise equal, but all byte-sized integers (notably char, int8_t, and
 // uint8_t) are compatible with each other. (Note: We aim to get rid of this
@@ skipping 158 matching lines @@
   }
 
   template <typename U,
             size_t N,
             typename std::enable_if<
                 internal::BufferCompat<T, U>::value>::type* = nullptr>
   void SetData(const U (&array)[N]) {
     SetData(array, N);
   }
 
-  void SetData(const BufferT& buf) { SetData(buf.data(), buf.size()); }
+  template <typename W,
+            typename std::enable_if<
+                HasDataAndSize<const W, const T>::value>::type* = nullptr>
+  void SetData(const W& w) {
+    SetData(w.data(), w.size());
+  }
 
   // Replace the data in the buffer with at most |max_elements| of data, using
   // the function |setter|, which should have the following signature:
   //   size_t setter(ArrayView<U> view)
   // |setter| is given an appropriately typed ArrayView of the area in which to
   // write the data (i.e. starting at the beginning of the buffer) and should
   // return the number of elements actually written. This number must be <=
   // |max_elements|.
   template <typename U = T,
             typename F,
@@ skipping 21 matching lines @@
   }
 
   template <typename U,
             size_t N,
             typename std::enable_if<
                 internal::BufferCompat<T, U>::value>::type* = nullptr>
   void AppendData(const U (&array)[N]) {
     AppendData(array, N);
   }
 
-  void AppendData(const BufferT& buf) { AppendData(buf.data(), buf.size()); }
+  template <typename W,
+            typename std::enable_if<
+                HasDataAndSize<const W, const T>::value>::type* = nullptr>
+  void AppendData(const W& w) {
+    AppendData(w.data(), w.size());
+  }
 
   template <typename U,
             typename std::enable_if<
                 internal::BufferCompat<T, U>::value>::type* = nullptr>
   void AppendData(const U& item) {
     AppendData(&item, 1);
   }
 
   // Append at most |max_elements| to the end of the buffer, using the function
   // |setter|, which should have the following signature:
@@ skipping 101 matching lines @@
   size_t capacity_;
   std::unique_ptr<T[]> data_;
 };
 
 // By far the most common sort of buffer.
 using Buffer = BufferT<uint8_t>;
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_BUFFER_H_