Moved PlatformMessage's to unique_ptrs

lib/ui/window/platform_configuration.cc

@@ -124,12 +124,12 @@ Dart_Handle SendPlatformMessage(Dart_Handle window,
   }
   if (Dart_IsNull(data_handle)) {
     dart_state->platform_configuration()->client()->HandlePlatformMessage(
-        fml::MakeRefCounted<PlatformMessage>(name, response));
+        std::make_unique<PlatformMessage>(name, response));
   } else {
     tonic::DartByteData data(data_handle);
     const uint8_t* buffer = static_cast<const uint8_t*>(data.data());
     dart_state->platform_configuration()->client()->HandlePlatformMessage(
-        fml::MakeRefCounted<PlatformMessage>(
+        std::make_unique<PlatformMessage>(
             name, std::vector<uint8_t>(buffer, buffer + data.length_in_bytes()),
             response));
   }
@@ -305,7 +305,7 @@ void PlatformConfiguration::UpdateAccessibilityFeatures(int32_t values) {
 }
 
 void PlatformConfiguration::DispatchPlatformMessage(
-    fml::RefPtr<PlatformMessage> message) {
+    std::unique_ptr<PlatformMessage> message) {
   std::shared_ptr<tonic::DartState> dart_state =
       dispatch_platform_message_.dart_state().lock();
   if (!dart_state) {

lib/ui/window/platform_configuration.h

@@ -87,7 +87,8 @@ class PlatformConfigurationClient {
   /// @param[in]  message  The message from the Flutter application to send to
   ///                      the underlying platform.
   ///
-  virtual void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) = 0;
+  virtual void HandlePlatformMessage(
+      std::unique_ptr<PlatformMessage> message) = 0;
 
   //--------------------------------------------------------------------------
   /// @brief      Returns the current collection of fonts available on the
@@ -309,7 +310,7 @@ class PlatformConfiguration final {
   /// @param[in]  message  The message sent from the embedder to the Dart
   ///                      application.
   ///
-  void DispatchPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  void DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message);
 
   //----------------------------------------------------------------------------
   /// @brief      Notifies the framework that the embedder encountered an

lib/ui/window/platform_configuration_unittests.cc

@@ -29,7 +29,8 @@ class DummyPlatformConfigurationClient : public PlatformConfigurationClient {
   void ScheduleFrame() override {}
   void Render(Scene* scene) override {}
   void UpdateSemantics(SemanticsUpdate* update) override {}
-  void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) override {}
+  void HandlePlatformMessage(
+      std::unique_ptr<PlatformMessage> message) override {}
   FontCollection& GetFontCollection() override { return font_collection_; }
   void UpdateIsolateDescription(const std::string isolate_name,
                                 int64_t isolate_port) override {}

lib/ui/window/platform_message.h

@@ -14,11 +14,15 @@
 
 namespace flutter {
 
-class PlatformMessage : public fml::RefCountedThreadSafe<PlatformMessage> {
-  FML_FRIEND_REF_COUNTED_THREAD_SAFE(PlatformMessage);
-  FML_FRIEND_MAKE_REF_COUNTED(PlatformMessage);
-
+class PlatformMessage {
  public:
+  PlatformMessage(std::string channel,
+                  std::vector<uint8_t> data,
+                  fml::RefPtr<PlatformMessageResponse> response);
+  PlatformMessage(std::string channel,
+                  fml::RefPtr<PlatformMessageResponse> response);
+  ~PlatformMessage();
+
   const std::string& channel() const { return channel_; }
   const std::vector<uint8_t>& data() const { return data_; }
   bool hasData() { return hasData_; }
@@ -28,13 +32,6 @@ class PlatformMessage : public fml::RefCountedThreadSafe<PlatformMessage> {
   }
 
  private:
-  PlatformMessage(std::string channel,
-                  std::vector<uint8_t> data,
-                  fml::RefPtr<PlatformMessageResponse> response);
-  PlatformMessage(std::string channel,
-                  fml::RefPtr<PlatformMessageResponse> response);
-  ~PlatformMessage();
-
   std::string channel_;
   std::vector<uint8_t> data_;
   bool hasData_;

runtime/runtime_controller.cc

@@ -239,7 +239,7 @@ bool RuntimeController::NotifyIdle(int64_t deadline, size_t freed_hint) {
 }
 
 bool RuntimeController::DispatchPlatformMessage(
-    fml::RefPtr<PlatformMessage> message) {
+    std::unique_ptr<PlatformMessage> message) {
   if (auto* platform_configuration = GetPlatformConfigurationIfAvailable()) {
     TRACE_EVENT1("flutter", "RuntimeController::DispatchPlatformMessage",
                  "mode", "basic");
@@ -320,7 +320,7 @@ void RuntimeController::UpdateSemantics(SemanticsUpdate* update) {
 
 // |PlatformConfigurationClient|
 void RuntimeController::HandlePlatformMessage(
-    fml::RefPtr<PlatformMessage> message) {
+    std::unique_ptr<PlatformMessage> message) {
   client_.HandlePlatformMessage(std::move(message));
 }
 

runtime/runtime_controller.h

@@ -411,7 +411,8 @@ class RuntimeController : public PlatformConfigurationClient {
   /// @return     If the message was dispatched to the running root isolate.
   ///             This may fail is an isolate is not running.
   ///
-  virtual bool DispatchPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  virtual bool DispatchPlatformMessage(
+      std::unique_ptr<PlatformMessage> message);
 
   //----------------------------------------------------------------------------
   /// @brief      Dispatch the specified pointer data message to the running
@@ -655,7 +656,7 @@ class RuntimeController : public PlatformConfigurationClient {
   void UpdateSemantics(SemanticsUpdate* update) override;
 
   // |PlatformConfigurationClient|
-  void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) override;
+  void HandlePlatformMessage(std::unique_ptr<PlatformMessage> message) override;
 
   // |PlatformConfigurationClient|
   FontCollection& GetFontCollection() override;

runtime/runtime_delegate.h

@@ -28,7 +28,8 @@ class RuntimeDelegate {
   virtual void UpdateSemantics(SemanticsNodeUpdates update,
                                CustomAccessibilityActionUpdates actions) = 0;
 
-  virtual void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) = 0;
+  virtual void HandlePlatformMessage(
+      std::unique_ptr<PlatformMessage> message) = 0;
 
   virtual FontCollection& GetFontCollection() = 0;
 

shell/common/engine.cc

@@ -203,13 +203,13 @@ Engine::RunStatus Engine::Run(RunConfiguration configuration) {
 
   auto service_id = runtime_controller_->GetRootIsolateServiceID();
   if (service_id.has_value()) {
-    fml::RefPtr<PlatformMessage> service_id_message =
-        fml::MakeRefCounted<flutter::PlatformMessage>(
+    std::unique_ptr<PlatformMessage> service_id_message =
+        std::make_unique<flutter::PlatformMessage>(
             kIsolateChannel,
             std::vector<uint8_t>(service_id.value().begin(),
                                  service_id.value().end()),
             nullptr);
-    HandlePlatformMessage(service_id_message);
+    HandlePlatformMessage(std::move(service_id_message));
   }
 
   return Engine::RunStatus::Success;
@@ -285,7 +285,7 @@ void Engine::SetViewportMetrics(const ViewportMetrics& metrics) {
   }
 }
 
-void Engine::DispatchPlatformMessage(fml::RefPtr<PlatformMessage> message) {
+void Engine::DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message) {
   std::string channel = message->channel();
   if (channel == kLifecycleChannel) {
     if (HandleLifecyclePlatformMessage(message.get())) {
@@ -338,7 +338,7 @@ bool Engine::HandleLifecyclePlatformMessage(PlatformMessage* message) {
 }
 
 bool Engine::HandleNavigationPlatformMessage(
-    fml::RefPtr<PlatformMessage> message) {
+    std::unique_ptr<PlatformMessage> message) {
   const auto& data = message->data();
 
   rapidjson::Document document;
@@ -477,7 +477,7 @@ void Engine::UpdateSemantics(SemanticsNodeUpdates update,
   delegate_.OnEngineUpdateSemantics(std::move(update), std::move(actions));
 }
 
-void Engine::HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) {
+void Engine::HandlePlatformMessage(std::unique_ptr<PlatformMessage> message) {
   if (message->channel() == kAssetChannel) {
     HandleAssetPlatformMessage(std::move(message));
   } else {
@@ -520,7 +520,8 @@ void Engine::ScheduleSecondaryVsyncCallback(uintptr_t id,
   animator_->ScheduleSecondaryVsyncCallback(id, callback);
 }
 
-void Engine::HandleAssetPlatformMessage(fml::RefPtr<PlatformMessage> message) {
+void Engine::HandleAssetPlatformMessage(
+    std::unique_ptr<PlatformMessage> message) {
   fml::RefPtr<PlatformMessageResponse> response = message->response();
   if (!response) {
     return;

shell/common/engine.h

@@ -178,7 +178,7 @@ class Engine final : public RuntimeDelegate,
     ///                      the underlying platform.
     ///
     virtual void OnEngineHandlePlatformMessage(
-        fml::RefPtr<PlatformMessage> message) = 0;
+        std::unique_ptr<PlatformMessage> message) = 0;
 
     //--------------------------------------------------------------------------
     /// @brief      Notifies the delegate that the root isolate of the
@@ -706,7 +706,7 @@ class Engine final : public RuntimeDelegate,
   /// @param[in]  message  The message sent from the embedder to the Dart
   ///                      application.
   ///
-  void DispatchPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  void DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message);
 
   //----------------------------------------------------------------------------
   /// @brief      Notifies the engine that the embedder has sent it a pointer
@@ -930,7 +930,7 @@ class Engine final : public RuntimeDelegate,
                        CustomAccessibilityActionUpdates actions) override;
 
   // |RuntimeDelegate|
-  void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) override;
+  void HandlePlatformMessage(std::unique_ptr<PlatformMessage> message) override;
 
   // |RuntimeDelegate|
   void OnRootIsolateCreated() override;
@@ -954,13 +954,14 @@ class Engine final : public RuntimeDelegate,
 
   bool HandleLifecyclePlatformMessage(PlatformMessage* message);
 
-  bool HandleNavigationPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  bool HandleNavigationPlatformMessage(
+      std::unique_ptr<PlatformMessage> message);
 
   bool HandleLocalizationPlatformMessage(PlatformMessage* message);
 
   void HandleSettingsPlatformMessage(PlatformMessage* message);
 
-  void HandleAssetPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  void HandleAssetPlatformMessage(std::unique_ptr<PlatformMessage> message);
 
   bool GetAssetAsBuffer(const std::string& name, std::vector<uint8_t>* data);
 

shell/common/engine_unittests.cc

@@ -25,7 +25,7 @@ class MockDelegate : public Engine::Delegate {
   MOCK_METHOD2(OnEngineUpdateSemantics,
                void(SemanticsNodeUpdates, CustomAccessibilityActionUpdates));
   MOCK_METHOD1(OnEngineHandlePlatformMessage,
-               void(fml::RefPtr<PlatformMessage>));
+               void(std::unique_ptr<PlatformMessage>));
   MOCK_METHOD0(OnPreEngineRestart, void());
   MOCK_METHOD0(OnRootIsolateCreated, void());
   MOCK_METHOD2(UpdateIsolateDescription, void(const std::string, int64_t));
@@ -49,7 +49,7 @@ class MockRuntimeDelegate : public RuntimeDelegate {
   MOCK_METHOD1(Render, void(std::unique_ptr<flutter::LayerTree>));
   MOCK_METHOD2(UpdateSemantics,
                void(SemanticsNodeUpdates, CustomAccessibilityActionUpdates));
-  MOCK_METHOD1(HandlePlatformMessage, void(fml::RefPtr<PlatformMessage>));
+  MOCK_METHOD1(HandlePlatformMessage, void(std::unique_ptr<PlatformMessage>));
   MOCK_METHOD0(GetFontCollection, FontCollection&());
   MOCK_METHOD0(OnRootIsolateCreated, void());
   MOCK_METHOD2(UpdateIsolateDescription, void(const std::string, int64_t));
@@ -65,13 +65,13 @@ class MockRuntimeController : public RuntimeController {
   MockRuntimeController(RuntimeDelegate& client, TaskRunners p_task_runners)
       : RuntimeController(client, p_task_runners) {}
   MOCK_METHOD0(IsRootIsolateRunning, bool());
-  MOCK_METHOD1(DispatchPlatformMessage, bool(fml::RefPtr<PlatformMessage>));
+  MOCK_METHOD1(DispatchPlatformMessage, bool(std::unique_ptr<PlatformMessage>));
   MOCK_METHOD3(LoadDartDeferredLibraryError,
                void(intptr_t, const std::string, bool));
   MOCK_CONST_METHOD0(GetDartVM, DartVM*());
 };
 
-fml::RefPtr<PlatformMessage> MakePlatformMessage(
+std::unique_ptr<PlatformMessage> MakePlatformMessage(
     const std::string& channel,
     const std::map<std::string, std::string>& values,
     fml::RefPtr<PlatformMessageResponse> response) {
@@ -92,7 +92,7 @@ fml::RefPtr<PlatformMessage> MakePlatformMessage(
   document.Accept(writer);
   const uint8_t* data = reinterpret_cast<const uint8_t*>(buffer.GetString());
 
-  fml::RefPtr<PlatformMessage> message = fml::MakeRefCounted<PlatformMessage>(
+  std::unique_ptr<PlatformMessage> message = std::make_unique<PlatformMessage>(
       channel, std::vector<uint8_t>(data, data + buffer.GetSize()), response);
   return message;
 }
@@ -176,9 +176,9 @@ TEST_F(EngineTest, DispatchPlatformMessageUnknown) {
 
     fml::RefPtr<PlatformMessageResponse> response =
         fml::MakeRefCounted<MockResponse>();
-    fml::RefPtr<PlatformMessage> message =
-        fml::MakeRefCounted<PlatformMessage>("foo", response);
-    engine->DispatchPlatformMessage(message);
+    std::unique_ptr<PlatformMessage> message =
+        std::make_unique<PlatformMessage>("foo", response);
+    engine->DispatchPlatformMessage(std::move(message));
   });
 }
 
@@ -206,9 +206,9 @@ TEST_F(EngineTest, DispatchPlatformMessageInitialRoute) {
         {"method", "setInitialRoute"},
         {"args", "test_initial_route"},
     };
-    fml::RefPtr<PlatformMessage> message =
+    std::unique_ptr<PlatformMessage> message =
         MakePlatformMessage("flutter/navigation", values, response);
-    engine->DispatchPlatformMessage(message);
+    engine->DispatchPlatformMessage(std::move(message));
     EXPECT_EQ(engine->InitialRoute(), "test_initial_route");
   });
 }
@@ -239,9 +239,9 @@ TEST_F(EngineTest, DispatchPlatformMessageInitialRouteIgnored) {
         {"method", "setInitialRoute"},
         {"args", "test_initial_route"},
     };
-    fml::RefPtr<PlatformMessage> message =
+    std::unique_ptr<PlatformMessage> message =
         MakePlatformMessage("flutter/navigation", values, response);
-    engine->DispatchPlatformMessage(message);
+    engine->DispatchPlatformMessage(std::move(message));
     EXPECT_EQ(engine->InitialRoute(), "");
   });
 }

shell/common/platform_view.cc

@@ -32,7 +32,7 @@ std::unique_ptr<VsyncWaiter> PlatformView::CreateVSyncWaiter() {
 }
 
 void PlatformView::DispatchPlatformMessage(
-    fml::RefPtr<PlatformMessage> message) {
+    std::unique_ptr<PlatformMessage> message) {
   delegate_.OnPlatformViewDispatchPlatformMessage(std::move(message));
 }
 
@@ -115,7 +115,8 @@ fml::WeakPtr<PlatformView> PlatformView::GetWeakPtr() const {
 void PlatformView::UpdateSemantics(SemanticsNodeUpdates update,
                                    CustomAccessibilityActionUpdates actions) {}
 
-void PlatformView::HandlePlatformMessage(fml::RefPtr<PlatformMessage> message) {
+void PlatformView::HandlePlatformMessage(
+    std::unique_ptr<PlatformMessage> message) {
   if (auto response = message->response())
     response->CompleteEmpty();
 }

shell/common/platform_view.h

@@ -114,7 +114,7 @@ class PlatformView {
     ///                      root isolate.
     ///
     virtual void OnPlatformViewDispatchPlatformMessage(
-        fml::RefPtr<PlatformMessage> message) = 0;
+        std::unique_ptr<PlatformMessage> message) = 0;
 
     //--------------------------------------------------------------------------
     /// @brief      Notifies the delegate that the platform view has encountered
@@ -379,7 +379,7 @@ class PlatformView {
   ///
   /// @param[in]  message  The platform message to deliver to the root isolate.
   ///
-  void DispatchPlatformMessage(fml::RefPtr<PlatformMessage> message);
+  void DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message);
 
   //----------------------------------------------------------------------------
   /// @brief      Overridden by embedders to perform actions in response to
@@ -395,7 +395,7 @@ class PlatformView {
   ///
   /// @param[in]  message  The message
   ///
-  virtual void HandlePlatformMessage(fml::RefPtr<PlatformMessage> message);
+  virtual void HandlePlatformMessage(std::unique_ptr<PlatformMessage> message);
 
   //----------------------------------------------------------------------------
   /// @brief      Used by embedders to dispatch an accessibility action to a