started supporting backwards compatible usage of setting handlers

Author: gaaclarke

shell/common/shell.cc

@@ -632,6 +632,13 @@ bool Shell::Setup(std::unique_ptr<PlatformView> platform_view,
 
   platform_view_ = std::move(platform_view);
   platform_message_handler_ = platform_view_->GetPlatformMessageHandler();
+  route_messages_through_platform_thread_.store(true);
+  task_runners_.GetPlatformTaskRunner()->PostTask(
+      [self = weak_factory_.GetWeakPtr()] {
+        if (self) {
+          self->route_messages_through_platform_thread_.store(false);
+        }
+      });
   engine_ = std::move(engine);
   rasterizer_ = std::move(rasterizer);
   io_manager_ = io_manager;
@@ -1183,7 +1190,30 @@ void Shell::OnEngineHandlePlatformMessage(
   }
 
   if (platform_message_handler_) {
-    platform_message_handler_->HandlePlatformMessage(std::move(message));
+    if (route_messages_through_platform_thread_) {
+      // We route messages through the platform thread temporarily when the
+      // shell is being initialized to be backwards compatible with setting
+      // message handlers in the same event as starting the isolate, but after
+      // it is started.
+      auto ui_task_runner = task_runners_.GetUITaskRunner();
+      task_runners_.GetPlatformTaskRunner()->PostTask(fml::MakeCopyable(
+          [weak_platform_message_handler =
+               std::weak_ptr<PlatformMessageHandler>(platform_message_handler_),
+           message = std::move(message), ui_task_runner]() mutable {
+            ui_task_runner->PostTask(fml::MakeCopyable(
+                [weak_platform_message_handler, message = std::move(message),
+                 ui_task_runner]() mutable {
+                  auto platform_message_handler =
+                      weak_platform_message_handler.lock();
+                  if (platform_message_handler) {
+                    platform_message_handler->HandlePlatformMessage(
+                        std::move(message));
+                  }
+                }));
+          }));
+    } else {
+      platform_message_handler_->HandlePlatformMessage(std::move(message));
+    }
   } else {
     task_runners_.GetPlatformTaskRunner()->PostTask(
         fml::MakeCopyable([view = platform_view_->GetWeakPtr(),

shell/common/shell.h

@@ -419,6 +419,7 @@ class Shell final : public PlatformView::Delegate,
   std::shared_ptr<fml::SyncSwitch> is_gpu_disabled_sync_switch_;
   std::shared_ptr<VolatilePathTracker> volatile_path_tracker_;
   std::shared_ptr<PlatformMessageHandler> platform_message_handler_;
+  std::atomic<bool> route_messages_through_platform_thread_ = false;
 
   fml::WeakPtr<Engine> weak_engine_;  // to be shared across threads
   fml::TaskRunnerAffineWeakPtr<Rasterizer>

shell/platform/darwin/ios/framework/Source/FlutterEngineTest.mm

@@ -220,22 +220,24 @@ - (void)testDeallocNotification {
 
 - (void)testSetHandlerAfterRun {
   FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"foobar"];
-  NSObject<FlutterPluginRegistrar>* registrar = [engine registrarForPlugin:@"foo"];
   XCTestExpectation* gotMessage = [self expectationWithDescription:@"gotMessage"];
-  fml::AutoResetWaitableEvent latch;
-  [engine run];
-  flutter::Shell& shell = engine.shell;
-  engine.shell.GetTaskRunners().GetUITaskRunner()->PostTask([&latch, &shell] {
-    flutter::Engine::Delegate& delegate = shell;
-    auto message = std::make_unique<flutter::PlatformMessage>("foo", nullptr);
-    delegate.OnEngineHandlePlatformMessage(std::move(message));
-    latch.Signal();
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSObject<FlutterPluginRegistrar>* registrar = [engine registrarForPlugin:@"foo"];
+    fml::AutoResetWaitableEvent latch;
+    [engine run];
+    flutter::Shell& shell = engine.shell;
+    engine.shell.GetTaskRunners().GetUITaskRunner()->PostTask([&latch, &shell] {
+      flutter::Engine::Delegate& delegate = shell;
+      auto message = std::make_unique<flutter::PlatformMessage>("foo", nullptr);
+      delegate.OnEngineHandlePlatformMessage(std::move(message));
+      latch.Signal();
+    });
+    latch.Wait();
+    [registrar.messenger setMessageHandlerOnChannel:@"foo"
+                               binaryMessageHandler:^(NSData* message, FlutterBinaryReply reply) {
+                                 [gotMessage fulfill];
+                               }];
   });
-  latch.Wait();
-  [registrar.messenger setMessageHandlerOnChannel:@"foo"
-                             binaryMessageHandler:^(NSData* message, FlutterBinaryReply reply) {
-                               [gotMessage fulfill];
-                             }];
   [self waitForExpectationsWithTimeout:1 handler:nil];
 }