Hookup view connected/disconnected events for platform view codepath (#21576)

This change adds support for forwarding scenic's viewConnected,
viewDisconnected and viewStateChanged events to flutter. The
corrensponding change on fuchsia side is at:
https://fuchsia-review.googlesource.com/c/topaz/+/434356

Test: Includes unittest to verify the events are forwarded.
Co-authored-by: NSanjay Chouksey <sanjayc@google.com>

shell/platform/fuchsia/flutter/platform_view.cc

@@ -250,7 +250,6 @@ void PlatformView::OnScenicEvent(
             }
             break;
           }
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
           case fuchsia::ui::gfx::Event::Tag::kViewConnected:
             OnChildViewConnected(event.gfx().view_connected().view_holder_id);
             break;
@@ -263,7 +262,6 @@ void PlatformView::OnScenicEvent(
                 event.gfx().view_state_changed().view_holder_id,
                 event.gfx().view_state_changed().state.is_rendering);
             break;
-#endif
           case fuchsia::ui::gfx::Event::Tag::Invalid:
             FML_DCHECK(false) << "Flutter PlatformView::OnScenicEvent: Got "
                                  "an invalid GFX event.";
@@ -321,26 +319,55 @@ void PlatformView::OnScenicEvent(
   }
 }
 
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
 void PlatformView::OnChildViewConnected(scenic::ResourceId view_holder_id) {
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
   task_runners_.GetUITaskRunner()->PostTask([view_holder_id]() {
     flutter::SceneHost::OnViewConnected(view_holder_id);
   });
+#endif  // LEGACY_FUCHSIA_EMBEDDER
+  std::string call = "{\"method\":\"View.viewConnected\",\"args\":null}";
+
+  fml::RefPtr<flutter::PlatformMessage> message =
+      fml::MakeRefCounted<flutter::PlatformMessage>(
+          "flutter/platform_views",
+          std::vector<uint8_t>(call.begin(), call.end()), nullptr);
+  DispatchPlatformMessage(message);
 }
 
 void PlatformView::OnChildViewDisconnected(scenic::ResourceId view_holder_id) {
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
   task_runners_.GetUITaskRunner()->PostTask([view_holder_id]() {
     flutter::SceneHost::OnViewDisconnected(view_holder_id);
   });
+#endif  // LEGACY_FUCHSIA_EMBEDDER
+  std::string call = "{\"method\":\"View.viewDisconnected\",\"args\":null}";
+
+  fml::RefPtr<flutter::PlatformMessage> message =
+      fml::MakeRefCounted<flutter::PlatformMessage>(
+          "flutter/platform_views",
+          std::vector<uint8_t>(call.begin(), call.end()), nullptr);
+  DispatchPlatformMessage(message);
 }
 
 void PlatformView::OnChildViewStateChanged(scenic::ResourceId view_holder_id,
                                            bool state) {
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
   task_runners_.GetUITaskRunner()->PostTask([view_holder_id, state]() {
     flutter::SceneHost::OnViewStateChanged(view_holder_id, state);
   });
+#endif  // LEGACY_FUCHSIA_EMBEDDER
+  std::ostringstream out;
+  std::string str_state = state ? "true" : "false";
+  out << "{\"method\":\"View.viewStateChanged\",\"args\":{\"state\":"
+      << str_state << "}}";
+  auto call = out.str();
+
+  fml::RefPtr<flutter::PlatformMessage> message =
+      fml::MakeRefCounted<flutter::PlatformMessage>(
+          "flutter/platform_views",
+          std::vector<uint8_t>(call.begin(), call.end()), nullptr);
+  DispatchPlatformMessage(message);
 }
-#endif
 
 static flutter::PointerData::Change GetChangeFromPointerEventPhase(
     fuchsia::ui::input::PointerEventPhase phase) {

shell/platform/fuchsia/flutter/platform_view.h

@@ -19,9 +19,7 @@
 
 #include "accessibility_bridge.h"
 
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
 #include <lib/ui/scenic/cpp/id.h>  // nogncheck
-#endif
 
 namespace flutter_runner {
 
@@ -134,11 +132,9 @@ class PlatformView final : public flutter::PlatformView,
   void OnScenicError(std::string error) override;
   void OnScenicEvent(std::vector<fuchsia::ui::scenic::Event> events) override;
 
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
   void OnChildViewConnected(scenic::ResourceId view_holder_id);
   void OnChildViewDisconnected(scenic::ResourceId view_holder_id);
   void OnChildViewStateChanged(scenic::ResourceId view_holder_id, bool state);
-#endif
 
   bool OnHandlePointerEvent(const fuchsia::ui::input::PointerEvent& pointer);
 

shell/platform/fuchsia/flutter/platform_view_unittest.cc

@@ -85,7 +85,9 @@ class MockPlatformViewDelegate : public flutter::PlatformView::Delegate {
       const flutter::ViewportMetrics& metrics) {}
   // |flutter::PlatformView::Delegate|
   void OnPlatformViewDispatchPlatformMessage(
-      fml::RefPtr<flutter::PlatformMessage> message) {}
+      fml::RefPtr<flutter::PlatformMessage> message) {
+    message_ = std::move(message);
+  }
   // |flutter::PlatformView::Delegate|
   void OnPlatformViewDispatchPointerDataPacket(
       std::unique_ptr<flutter::PointerDataPacket> packet) {}
@@ -119,11 +121,13 @@ class MockPlatformViewDelegate : public flutter::PlatformView::Delegate {
   bool SemanticsEnabled() const { return semantics_enabled_; }
   int32_t SemanticsFeatures() const { return semantics_features_; }
   flutter::Surface* surface() const { return surface_.get(); }
+  fml::RefPtr<flutter::PlatformMessage>& message() { return message_; }
 
  private:
   std::unique_ptr<flutter::Surface> surface_;
   bool semantics_enabled_ = false;
   int32_t semantics_features_ = 0;
+  fml::RefPtr<flutter::PlatformMessage> message_;
 };
 
 class MockFocuser : public fuchsia::ui::views::Focuser {
@@ -639,6 +643,91 @@ TEST_F(PlatformViewTests, RequestFocusFailTest) {
   EXPECT_EQ(out.str(), result);
 }
 
+// Test to make sure that PlatformView forward messages on the
+// "flutter/platform_views" channel, for viewConnected/viewDisconnected and
+// viewStateChanged events.
+TEST_F(PlatformViewTests, ViewEventsTest) {
+  MockPlatformViewDelegate delegate;
+
+  fuchsia::ui::scenic::SessionListenerPtr session_listener;
+  std::vector<fuchsia::ui::scenic::Event> events;
+  sys::testing::ServiceDirectoryProvider services_provider(dispatcher());
+
+  flutter::TaskRunners task_runners = flutter::TaskRunners(
+      "test_runners", nullptr, nullptr,
+      flutter_runner::CreateFMLTaskRunner(async_get_default_dispatcher()),
+      nullptr);
+
+  auto platform_view = flutter_runner::PlatformView(
+      delegate,                               // delegate
+      "test_platform_view",                   // label
+      fuchsia::ui::views::ViewRef{},          // view_ref
+      std::move(task_runners),                // task_runners
+      services_provider.service_directory(),  // runner_services
+      nullptr,  // parent_environment_service_provider_handle
+      session_listener.NewRequest(),  // session_listener_request
+      nullptr,                        // focuser,
+      nullptr,                        // on_session_listener_error_callback
+      nullptr,                        // on_enable_wireframe_callback,
+      nullptr,                        // on_create_view_callback,
+      nullptr,                        // on_update_view_callback,
+      nullptr,                        // on_destroy_view_callback,
+      nullptr,                        // on_create_surface_callback,
+      fml::TimeDelta::Zero(),         // vsync_offset
+      ZX_HANDLE_INVALID               // vsync_event_handle
+  );
+  RunLoopUntilIdle();
+
+  // ViewConnected event.
+  events.clear();
+  events.emplace_back(fuchsia::ui::scenic::Event::WithGfx(
+      fuchsia::ui::gfx::Event::WithViewConnected(
+          fuchsia::ui::gfx::ViewConnectedEvent{
+              .view_holder_id = 0,
+          })));
+  session_listener->OnScenicEvent(std::move(events));
+  RunLoopUntilIdle();
+
+  auto data = delegate.message()->data();
+  auto call = std::string(data.begin(), data.end());
+  std::string expected = "{\"method\":\"View.viewConnected\",\"args\":null}";
+  EXPECT_EQ(expected, call);
+
+  // ViewDisconnected event.
+  events.clear();
+  events.emplace_back(fuchsia::ui::scenic::Event::WithGfx(
+      fuchsia::ui::gfx::Event::WithViewDisconnected(
+          fuchsia::ui::gfx::ViewDisconnectedEvent{
+              .view_holder_id = 0,
+          })));
+  session_listener->OnScenicEvent(std::move(events));
+  RunLoopUntilIdle();
+
+  data = delegate.message()->data();
+  call = std::string(data.begin(), data.end());
+  expected = "{\"method\":\"View.viewDisconnected\",\"args\":null}";
+  EXPECT_EQ(expected, call);
+
+  // ViewStateChanged event.
+  events.clear();
+  events.emplace_back(fuchsia::ui::scenic::Event::WithGfx(
+      fuchsia::ui::gfx::Event::WithViewStateChanged(
+          fuchsia::ui::gfx::ViewStateChangedEvent{
+              .view_holder_id = 0,
+              .state =
+                  fuchsia::ui::gfx::ViewState{
+                      .is_rendering = true,
+                  },
+          })));
+  session_listener->OnScenicEvent(std::move(events));
+  RunLoopUntilIdle();
+
+  data = delegate.message()->data();
+  call = std::string(data.begin(), data.end());
+  expected = "{\"method\":\"View.viewStateChanged\",\"args\":{\"state\":true}}";
+  EXPECT_EQ(expected, call);
+}
+
 // Test to make sure that PlatformView correctly returns a Surface instance
 // that can surface the provided gr_context and view_embedder.
 TEST_F(PlatformViewTests, CreateSurfaceTest) {