switched to MallocMapping

Author: gaaclarke

fml/mapping.cc

@@ -82,39 +82,10 @@ const uint8_t* DataMapping::GetMapping() const {
 }
 
 // NonOwnedMapping
-NonOwnedMapping::NonOwnedMapping()
-    : 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),
-      uses_free_(false) {}
-
-NonOwnedMapping::NonOwnedMapping(fml::NonOwnedMapping&& mapping)
-    : data_(mapping.data_),
-      size_(mapping.size_),
-      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;
-}
+    : data_(data), size_(size), release_proc_(release_proc) {}
 
 NonOwnedMapping::~NonOwnedMapping() {
   if (release_proc_) {
@@ -130,11 +101,37 @@ const uint8_t* NonOwnedMapping::GetMapping() const {
   return data_;
 }
 
-const uint8_t* NonOwnedMapping::Release() {
+// MallocMapping
+MallocMapping::MallocMapping() : data_(nullptr), size_(0) {}
+
+MallocMapping::MallocMapping(const uint8_t* data, size_t size)
+    : data_(data), size_(size) {}
+
+MallocMapping::MallocMapping(fml::MallocMapping&& mapping)
+    : data_(mapping.data_), size_(mapping.size_) {
+  mapping.data_ = nullptr;
+  mapping.size_ = 0;
+}
+
+MallocMapping::~MallocMapping() {
+  if (data_) {
+    free(const_cast<uint8_t*>(data_));
+    data_ = nullptr;
+  }
+}
+
+size_t MallocMapping::GetSize() const {
+  return size_;
+}
+
+const uint8_t* MallocMapping::GetMapping() const {
+  return data_;
+}
+
+const uint8_t* MallocMapping::Release() {
   const uint8_t* result = data_;
   data_ = nullptr;
   size_ = 0;
-  release_proc_ = nullptr;
   return result;
 }
 

fml/mapping.h

@@ -105,24 +105,45 @@ class DataMapping final : public Mapping {
 class NonOwnedMapping final : public Mapping {
  public:
   using ReleaseProc = std::function<void(const uint8_t* data, size_t size)>;
-  NonOwnedMapping();
-
   NonOwnedMapping(const uint8_t* data,
                   size_t size,
                   const ReleaseProc& release_proc = nullptr);
 
-  NonOwnedMapping(fml::NonOwnedMapping&& mapping);
-
   ~NonOwnedMapping() override;
 
+  // |Mapping|
+  size_t GetSize() const override;
+
+  // |Mapping|
+  const uint8_t* GetMapping() const override;
+
+ private:
+  const uint8_t* data_;
+  const size_t size_;
+  const ReleaseProc release_proc_;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(NonOwnedMapping);
+};
+
+/// A Mapping like NonOwnedMapping, but uses Free as its release proc.
+class MallocMapping final : public Mapping {
+ public:
+  MallocMapping();
+
+  MallocMapping(const uint8_t* data, size_t size);
+
+  MallocMapping(fml::MallocMapping&& mapping);
+
+  ~MallocMapping() override;
+
   /// 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) {
+  static MallocMapping Copy(const T* begin, const T* end) {
     size_t length = end - begin;
-    auto result = NonOwnedMapping::WithFree(
-        reinterpret_cast<uint8_t*>(malloc(length)), length);
+    auto result =
+        MallocMapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
     memcpy(const_cast<uint8_t*>(result.GetMapping()), begin, length);
     return result;
   }
@@ -136,21 +157,11 @@ class NonOwnedMapping final : public Mapping {
   /// Removes ownership of the data buffer.
   const uint8_t* Release();
 
-  /// 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);
+  FML_DISALLOW_COPY_AND_ASSIGN(MallocMapping);
 };
 
 class SymbolMapping final : public Mapping {

lib/ui/window/platform_configuration.cc

@@ -131,7 +131,7 @@ Dart_Handle SendPlatformMessage(Dart_Handle window,
     dart_state->platform_configuration()->client()->HandlePlatformMessage(
         std::make_unique<PlatformMessage>(
             name,
-            fml::NonOwnedMapping::Copy(buffer, buffer + data.length_in_bytes()),
+            fml::MallocMapping::Copy(buffer, buffer + data.length_in_bytes()),
             response));
   }
 
@@ -339,7 +339,7 @@ void PlatformConfiguration::DispatchPlatformMessage(
 
 void PlatformConfiguration::DispatchSemanticsAction(int32_t id,
                                                     SemanticsAction action,
-                                                    fml::NonOwnedMapping args) {
+                                                    fml::MallocMapping args) {
   std::shared_ptr<tonic::DartState> dart_state =
       dispatch_semantics_action_.dart_state().lock();
   if (!dart_state) {

lib/ui/window/platform_configuration.h

@@ -325,7 +325,7 @@ class PlatformConfiguration final {
   ///
   void DispatchSemanticsAction(int32_t id,
                                SemanticsAction action,
-                               fml::NonOwnedMapping args);
+                               fml::MallocMapping args);
 
   //----------------------------------------------------------------------------
   /// @brief      Registers a callback to be invoked when the framework has

lib/ui/window/platform_message.cc

@@ -9,7 +9,7 @@
 namespace flutter {
 
 PlatformMessage::PlatformMessage(std::string channel,
-                                 fml::NonOwnedMapping data,
+                                 fml::MallocMapping data,
                                  fml::RefPtr<PlatformMessageResponse> response)
     : channel_(std::move(channel)),
       data_(std::move(data)),

lib/ui/window/platform_message.h

@@ -17,25 +17,25 @@ namespace flutter {
 class PlatformMessage {
  public:
   PlatformMessage(std::string channel,
-                  fml::NonOwnedMapping data,
+                  fml::MallocMapping data,
                   fml::RefPtr<PlatformMessageResponse> response);
   PlatformMessage(std::string channel,
                   fml::RefPtr<PlatformMessageResponse> response);
   ~PlatformMessage();
 
   const std::string& channel() const { return channel_; }
-  const fml::NonOwnedMapping& data() const { return data_; }
+  const fml::MallocMapping& data() const { return data_; }
   bool hasData() { return hasData_; }
 
   const fml::RefPtr<PlatformMessageResponse>& response() const {
     return response_;
   }
 
-  fml::NonOwnedMapping releaseData() { return std::move(data_); }
+  fml::MallocMapping releaseData() { return std::move(data_); }
 
  private:
   std::string channel_;
-  fml::NonOwnedMapping data_;
+  fml::MallocMapping data_;
   bool hasData_;
   fml::RefPtr<PlatformMessageResponse> response_;
 };

runtime/runtime_controller.cc

@@ -278,7 +278,7 @@ bool RuntimeController::DispatchKeyDataPacket(const KeyDataPacket& packet,
 
 bool RuntimeController::DispatchSemanticsAction(int32_t id,
                                                 SemanticsAction action,
-                                                fml::NonOwnedMapping args) {
+                                                fml::MallocMapping args) {
   TRACE_EVENT1("flutter", "RuntimeController::DispatchSemanticsAction", "mode",
                "basic");
   if (auto* platform_configuration = GetPlatformConfigurationIfAvailable()) {

runtime/runtime_controller.h

@@ -453,7 +453,7 @@ class RuntimeController : public PlatformConfigurationClient {
   ///
   bool DispatchSemanticsAction(int32_t id,
                                SemanticsAction action,
-                               fml::NonOwnedMapping args);
+                               fml::MallocMapping args);
 
   //----------------------------------------------------------------------------
   /// @brief      Gets the main port identifier of the root isolate.

shell/common/engine.cc

@@ -37,8 +37,8 @@ static constexpr char kSettingsChannel[] = "flutter/settings";
 static constexpr char kIsolateChannel[] = "flutter/isolate";
 
 namespace {
-fml::NonOwnedMapping MakeMapping(const std::string& str) {
-  return fml::NonOwnedMapping::Copy(str.c_str(), str.c_str() + str.length());
+fml::MallocMapping MakeMapping(const std::string& str) {
+  return fml::MallocMapping::Copy(str.c_str(), str.c_str() + str.length());
 }
 }  // namespace
 
@@ -433,7 +433,7 @@ void Engine::DispatchKeyDataPacket(std::unique_ptr<KeyDataPacket> packet,
 
 void Engine::DispatchSemanticsAction(int id,
                                      SemanticsAction action,
-                                     fml::NonOwnedMapping args) {
+                                     fml::MallocMapping args) {
   runtime_controller_->DispatchSemanticsAction(id, action, std::move(args));
 }
 

shell/common/engine.h

@@ -757,7 +757,7 @@ class Engine final : public RuntimeDelegate,
   ///
   void DispatchSemanticsAction(int id,
                                SemanticsAction action,
-                               fml::NonOwnedMapping args);
+                               fml::MallocMapping args);
 
   //----------------------------------------------------------------------------
   /// @brief      Notifies the engine that the embedder has expressed an opinion