started tracking usage of free in instance variable

Author: gaaclarke

fml/mapping.cc

@@ -83,20 +83,37 @@ const uint8_t* DataMapping::GetMapping() const {
 
 // NonOwnedMapping
 NonOwnedMapping::NonOwnedMapping()
-    : data_(nullptr), size_(0), release_proc_() {}
+    : data_(nullptr), size_(0), release_proc_(), uses_free_(false) {}
 
 NonOwnedMapping::NonOwnedMapping(const uint8_t* data,
                                  size_t size,
                                  const ReleaseProc& release_proc)
-    : data_(data), size_(size), release_proc_(release_proc) {}
+    : data_(data),
+      size_(size),
+      release_proc_(release_proc),
+      uses_free_(false) {}
 
 NonOwnedMapping::NonOwnedMapping(fml::NonOwnedMapping&& mapping)
     : data_(mapping.data_),
       size_(mapping.size_),
-      release_proc_(mapping.release_proc_) {
+      release_proc_(mapping.release_proc_),
+      uses_free_(mapping.uses_free_) {
   mapping.data_ = nullptr;
   mapping.size_ = 0;
   mapping.release_proc_ = nullptr;
+  mapping.uses_free_ = false;
+}
+
+namespace {
+void FreeProc(const uint8_t* data, size_t size) {
+  free(const_cast<uint8_t*>(data));
+}
+}  // namespace
+
+NonOwnedMapping NonOwnedMapping::WithFree(const uint8_t* data, size_t size) {
+  auto result = NonOwnedMapping(data, size, FreeProc);
+  result.uses_free_ = true;
+  return result;
 }
 
 NonOwnedMapping::~NonOwnedMapping() {
@@ -113,10 +130,6 @@ const uint8_t* NonOwnedMapping::GetMapping() const {
   return data_;
 }
 
-void NonOwnedMapping::FreeProc(const uint8_t* data, size_t size) {
-  free(const_cast<uint8_t*>(data));
-}
-
 const uint8_t* NonOwnedMapping::Release() {
   const uint8_t* result = data_;
   data_ = nullptr;

fml/mapping.h

@@ -115,17 +115,14 @@ class NonOwnedMapping final : public Mapping {
 
   ~NonOwnedMapping() override;
 
-  /// A ReleaseProc that uses `free` which interfaces well with C/ObjC.
-  static void FreeProc(const uint8_t* data, size_t size);
-
   /// Copies the data from `begin` to `end`.
   /// It's templated since void* arithemetic isn't allowed and we want support
   /// for `uint8_t` and `char`.
   template <typename T>
   static NonOwnedMapping Copy(const T* begin, const T* end) {
     size_t length = end - begin;
-    auto result = NonOwnedMapping(reinterpret_cast<uint8_t*>(malloc(length)),
-                                  length, FreeProc);
+    auto result = NonOwnedMapping::WithFree(
+        reinterpret_cast<uint8_t*>(malloc(length)), length);
     memcpy(const_cast<uint8_t*>(result.GetMapping()), begin, length);
     return result;
   }
@@ -139,12 +136,19 @@ class NonOwnedMapping final : public Mapping {
   /// Removes ownership of the data buffer.
   const uint8_t* Release();
 
-  ReleaseProc GetReleaseProc() const { return release_proc_; }
+  /// Returns true if the Mapping uses `free` to delete the memory.
+  /// This is important for passing ownership to C/ObjC code like NSData.  It
+  /// has to be a special case because std::function comparisions aren't
+  /// possible.
+  bool UsesFree() const { return uses_free_; }
 
  private:
+  static NonOwnedMapping WithFree(const uint8_t* data, size_t size);
+
   const uint8_t* data_;
   size_t size_;
   ReleaseProc release_proc_;
+  bool uses_free_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(NonOwnedMapping);
 };