Fix build issues for the embedder on Windows. (#5386)

shell/gpu/gpu_surface_gl.cc

@@ -95,10 +95,9 @@ static sk_sp<SkSurface> WrapOnscreenSurface(GrContext* context,
   GrGLenum format;
   const SkColorType color_type = FirstSupportedColorType(context, &format);
 
-  const GrGLFramebufferInfo framebuffer_info = {
-      .fFBOID = static_cast<GrGLuint>(fbo),
-      .fFormat = format,
-  };
+  GrGLFramebufferInfo framebuffer_info = {};
+  framebuffer_info.fFBOID = static_cast<GrGLuint>(fbo);
+  framebuffer_info.fFormat = format;
 
   GrBackendRenderTarget render_target(size.fWidth,      // width
                                       size.fHeight,     // height

shell/platform/embedder/embedder.cc

@@ -31,16 +31,14 @@
 #include "lib/fxl/functional/make_copyable.h"
 
 #define SAFE_ACCESS(pointer, member, default_value)                      \
-  ({                                                                     \
-    auto _return_value =                                                 \
-        static_cast<__typeof__(pointer->member)>((default_value));       \
+  ([=]() {                                                               \
     if (offsetof(std::remove_pointer<decltype(pointer)>::type, member) + \
             sizeof(pointer->member) <=                                   \
         pointer->struct_size) {                                          \
-      _return_value = pointer->member;                                   \
+      return pointer->member;                                            \
     }                                                                    \
-    _return_value;                                                       \
-  })
+    return static_cast<decltype(pointer->member)>((default_value));      \
+  })()
 
 bool IsRendererValid(const FlutterRendererConfig* config) {
   if (config == nullptr || config->type != kOpenGL) {
@@ -112,11 +110,11 @@ FlutterResult FlutterEngineRun(size_t version,
          user_data](fxl::RefPtr<blink::PlatformMessage> message) {
           auto handle = new FlutterPlatformMessageResponseHandle();
           const FlutterPlatformMessage incoming_message = {
-              .struct_size = sizeof(FlutterPlatformMessage),
-              .channel = message->channel().c_str(),
-              .message = message->data().data(),
-              .message_size = message->data().size(),
-              .response_handle = handle,
+              sizeof(FlutterPlatformMessage),  // struct_size
+              message->channel().c_str(),      // channel
+              message->data().data(),          // message
+              message->data().size(),          // message_size
+              handle,                          // response_handle
           };
           handle->message = std::move(message);
           return ptr(&incoming_message, user_data);
@@ -188,12 +186,12 @@ FlutterResult FlutterEngineRun(size_t version,
   );
 
   shell::PlatformViewEmbedder::DispatchTable dispatch_table = {
-      .gl_make_current_callback = make_current,
-      .gl_clear_current_callback = clear_current,
-      .gl_present_callback = present,
-      .gl_fbo_callback = fbo_callback,
-      .platform_message_response_callback = platform_message_response_callback,
-      .gl_make_resource_current_callback = make_resource_current_callback,
+      make_current,                        // gl_make_current_callback
+      clear_current,                       // gl_clear_current_callback
+      present,                             // gl_present_callback
+      fbo_callback,                        // gl_fbo_callback
+      platform_message_response_callback,  // platform_message_response_callback
+      make_resource_current_callback,      // gl_make_resource_current_callback
   };
 
   shell::Shell::CreateCallback<shell::PlatformView> on_create_platform_view =

shell/platform/embedder/tests/embedder_unittests.cc

@@ -16,23 +16,26 @@ TEST(EmbedderTest, MustNotRunWithInvalidArgs) {
 }
 
 TEST(EmbedderTest, CanLaunchAndShutdownWithValidProjectArgs) {
-  FlutterOpenGLRendererConfig renderer = {
-      .struct_size = sizeof(FlutterOpenGLRendererConfig),
-      .make_current = [](void*) { return false; },
-      .clear_current = [](void*) { return false; },
-      .present = [](void*) { return false; },
-      .fbo_callback = [](void*) -> uint32_t { return 0; },
-  };
+  FlutterOpenGLRendererConfig renderer = {};
+  renderer.struct_size = sizeof(FlutterOpenGLRendererConfig);
+  renderer.make_current = [](void*) { return false; };
+  renderer.clear_current = [](void*) { return false; };
+  renderer.present = [](void*) { return false; };
+  renderer.fbo_callback = [](void*) -> uint32_t { return 0; };
 
   std::string main =
       std::string(testing::GetFixturesPath()) + "/simple_main.dart";
 
-  FlutterRendererConfig config = {.type = FlutterRendererType::kOpenGL,
-                                  .open_gl = renderer};
-  FlutterProjectArgs args = {.struct_size = sizeof(FlutterProjectArgs),
-                             .assets_path = "",
-                             .main_path = main.c_str(),
-                             .packages_path = ""};
+  FlutterRendererConfig config = {};
+  config.type = FlutterRendererType::kOpenGL;
+  config.open_gl = renderer;
+
+  FlutterProjectArgs args = {};
+  args.struct_size = sizeof(FlutterProjectArgs);
+  args.assets_path = "";
+  args.main_path = main.c_str();
+  args.packages_path = "";
+
   FlutterEngine engine = nullptr;
   FlutterResult result = FlutterEngineRun(FLUTTER_ENGINE_VERSION, &config,
                                           &args, nullptr, &engine);