[embedder][glfw] Add support for locales to glfw shell

BUILD.gn

@@ -4,6 +4,7 @@
 
 import("//flutter/common/config.gni")
 import("//flutter/shell/platform/config.gni")
+import("//flutter/shell/platform/glfw/config.gni")
 import("//flutter/testing/testing.gni")
 
 # Whether to build the dartdevc sdk, libraries, and source files
@@ -140,6 +141,10 @@ group("flutter") {
       if (is_linux) {
         public_deps +=
             [ "//flutter/shell/platform/linux:flutter_linux_unittests" ]
+        if (build_glfw_shell) {
+          public_deps +=
+              [ "//flutter/shell/platform/glfw:flutter_glfw_unittests" ]
+        }
       }
 
       if (is_mac) {

ci/licenses_golden/licenses_flutter

@@ -1284,6 +1284,8 @@ FILE: ../../../flutter/shell/platform/glfw/client_wrapper/plugin_registrar_glfw_
 FILE: ../../../flutter/shell/platform/glfw/event_loop.cc
 FILE: ../../../flutter/shell/platform/glfw/event_loop.h
 FILE: ../../../flutter/shell/platform/glfw/flutter_glfw.cc
+FILE: ../../../flutter/shell/platform/glfw/flutter_glfw_private.h
+FILE: ../../../flutter/shell/platform/glfw/flutter_glfw_test.cc
 FILE: ../../../flutter/shell/platform/glfw/glfw_event_loop.cc
 FILE: ../../../flutter/shell/platform/glfw/glfw_event_loop.h
 FILE: ../../../flutter/shell/platform/glfw/headless_event_loop.cc

shell/platform/glfw/BUILD.gn

@@ -2,6 +2,8 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import("//flutter/testing/testing.gni")
+
 _public_headers = [ "public/flutter_glfw.h" ]
 
 # Any files that are built by clients (client_wrapper code, library headers for
@@ -32,6 +34,7 @@ source_set("flutter_glfw") {
     "event_loop.cc",
     "event_loop.h",
     "flutter_glfw.cc",
+    "flutter_glfw_private.h",
     "glfw_event_loop.cc",
     "glfw_event_loop.h",
     "headless_event_loop.cc",
@@ -71,6 +74,22 @@ source_set("flutter_glfw") {
   }
 }
 
+test_fixtures("flutter_glfw_fixtures") {
+  fixtures = []
+}
+
+executable("flutter_glfw_unittests") {
+  testonly = true
+  deps = [
+    ":flutter_glfw_fixtures",
+    ":flutter_glfw_headers",
+    ":flutter_glfw",
+    "//flutter/shell/platform/embedder:embedder_headers",
+    "//flutter/testing",
+  ]
+  sources = ["flutter_glfw_test.cc"]
+}
+
 copy("publish_headers_glfw") {
   sources = _public_headers
   outputs = [ "$root_out_dir/{{source_file_part}}" ]

shell/platform/glfw/flutter_glfw.cc

@@ -12,11 +12,14 @@
 #include <cstdlib>
 #include <filesystem>
 #include <iostream>
+#include <list>
+#include <string>
 
 #include "flutter/shell/platform/common/cpp/client_wrapper/include/flutter/plugin_registrar.h"
 #include "flutter/shell/platform/common/cpp/incoming_message_dispatcher.h"
 #include "flutter/shell/platform/common/cpp/path_utils.h"
 #include "flutter/shell/platform/embedder/embedder.h"
+#include "flutter/shell/platform/glfw/flutter_glfw_private.h"
 #include "flutter/shell/platform/glfw/glfw_event_loop.h"
 #include "flutter/shell/platform/glfw/headless_event_loop.h"
 #include "flutter/shell/platform/glfw/key_event_handler.h"
@@ -690,6 +693,123 @@ static bool RunFlutterEngine(
   return true;
 }
 
+const char* GetLocaleStringFromEnvironmentVariables(const char* language,
+                                                    const char* lc_all,
+                                                    const char* lc_messages,
+                                                    const char* lang) {
+  const char* retval;
+  retval = language;
+  if ((retval != NULL) && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = lc_all;
+  if ((retval != NULL) && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = lc_messages;
+  if ((retval != NULL) && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = lang;
+  if ((retval != NULL) && (retval[0] != '\0')) {
+    return retval;
+  }
+
+  return NULL;
+}
+
+const char* GetLocaleStringFromEnvironment() {
+  return GetLocaleStringFromEnvironmentVariables(
+      getenv("LANGUAGE"), getenv("LC_ALL"), getenv("LC_MESSAGES"),
+      getenv("LANG"));
+}
+
+// Parse a locale into its components.
+void ParseLocale(const std::string& locale,
+                 std::string* language,
+                 std::string* territory,
+                 std::string* codeset,
+                 std::string* modifier) {
+  // Locales are in the form "language[_territory][.codeset][@modifier]"
+  std::string::size_type end = locale.size();
+  std::string::size_type modifier_pos = locale.rfind('@');
+  if (modifier_pos != std::string::npos) {
+    *modifier = locale.substr(modifier_pos + 1, end - modifier_pos - 1);
+    end = modifier_pos;
+  }
+
+  std::string::size_type codeset_pos = locale.rfind('.');
+  if (codeset_pos != std::string::npos) {
+    *codeset = locale.substr(codeset_pos + 1, end - codeset_pos - 1);
+    end = codeset_pos;
+  }
+
+  std::string::size_type territory_pos = locale.rfind('_');
+  if (territory_pos != std::string::npos) {
+    *territory = locale.substr(territory_pos + 1, end - territory_pos - 1);
+    end = territory_pos;
+  }
+
+  *language = locale.substr(0, end);
+}
+
+std::vector<std::unique_ptr<FlutterLocale>> GetLocales(
+    const char* locale_string,
+    std::list<std::string>& locale_storage) {
+  if (!locale_string || locale_string[0] == '\0') {
+    locale_string = "C";
+  }
+  std::istringstream locales_stream(locale_string);
+  std::vector<std::unique_ptr<FlutterLocale>> locales;
+  std::string s;
+  while (getline(locales_stream, s, ':')) {
+    locales.push_back(std::make_unique<FlutterLocale>());
+    std::string language, territory, codeset, modifier;
+    ParseLocale(s, &language, &territory, &codeset, &modifier);
+    FlutterLocale* locale = locales.back().get();
+    locale->struct_size = sizeof(FlutterLocale);
+    if (!language.empty()) {
+      locale_storage.push_back(language);
+      locale->language_code = locale_storage.back().c_str();
+    }
+    if (!territory.empty()) {
+      locale_storage.push_back(territory);
+      locale->country_code = locale_storage.back().c_str();
+    }
+    if (!codeset.empty()) {
+      locale_storage.push_back(codeset);
+      locale->script_code = locale_storage.back().c_str();
+    }
+    if (!modifier.empty()) {
+      locale_storage.push_back(modifier);
+      locale->variant_code = locale_storage.back().c_str();
+    }
+  }
+  return locales;
+}
+
+// Returns parsed locales fetched from the environment.
+std::vector<std::unique_ptr<FlutterLocale>> GetLocalesFromEnvironment(
+    std::list<std::string>& locale_storage) {
+  return GetLocales(GetLocaleStringFromEnvironment(), locale_storage);
+}
+
+// Passes locale information to the Flutter engine.
+static void SetUpLocales(FlutterDesktopEngineState* state) {
+  // Helper to extend lifetime of the strings passed to Flutter.
+  std::list<std::string> locale_storage;
+  std::vector<std::unique_ptr<FlutterLocale>> locales =
+      GetLocalesFromEnvironment(locale_storage);
+  FlutterLocale** locales_array =
+      reinterpret_cast<FlutterLocale**>(&locales[0]);
+  FlutterEngineResult result = FlutterEngineUpdateLocales(
+      state->flutter_engine, const_cast<const FlutterLocale**>(locales_array),
+      locales.size());
+  if (result != kSuccess) {
+    std::cerr << "Failed to set up Flutter locales." << std::endl;
+  }
+}
+
 // Populates |state|'s helper object fields that are common to normal and
 // headless mode.
 //
@@ -713,6 +833,8 @@ static void SetUpCommonEngineState(FlutterDesktopEngineState* state,
   // System channel handler.
   state->platform_handler = std::make_unique<flutter::PlatformHandler>(
       state->internal_plugin_registrar->messenger(), window);
+
+  SetUpLocales(state);
 }
 
 bool FlutterDesktopInit() {

shell/platform/glfw/flutter_glfw_private.h

@@ -0,0 +1,30 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_GLFW_FLUTTER_GLFW_PRIVATE_H_
+#define FLUTTER_SHELL_PLATFORM_GLFW_FLUTTER_GLFW_PRIVATE_H_
+
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "flutter/shell/platform/embedder/embedder.h"
+
+const char* GetLocaleStringFromEnvironmentVariables(const char* language,
+                                                    const char* lc_all,
+                                                    const char* lc_messages,
+                                                    const char* lang);
+
+void ParseLocale(const std::string& locale,
+                 std::string* language,
+                 std::string* territory,
+                 std::string* codeset,
+                 std::string* modifier);
+
+std::vector<std::unique_ptr<FlutterLocale>> GetLocales(
+    const char* locale_string,
+    std::list<std::string>& locale_storage);
+
+#endif  // FLUTTER_SHELL_PLATFORM_GLFW_FLUTTER_GLFW_PRIVATE_H_

shell/platform/glfw/flutter_glfw_test.cc

@@ -0,0 +1,138 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/glfw/flutter_glfw_private.h"
+
+#include "gtest/gtest.h"
+
+TEST(FlutterGlfwTest, GetLocaleStringFromEnvironment) {
+  EXPECT_EQ(
+      GetLocaleStringFromEnvironmentVariables("sv:de", NULL, NULL, "sv_SE"),
+      "sv:de");
+  EXPECT_EQ(
+      GetLocaleStringFromEnvironmentVariables(NULL, "en_EN", NULL, "sv_SE"),
+      "en_EN");
+  EXPECT_EQ(
+      GetLocaleStringFromEnvironmentVariables(NULL, NULL, "de_DE", "sv_SE"),
+      "de_DE");
+  EXPECT_EQ(GetLocaleStringFromEnvironmentVariables(NULL, NULL, NULL, "sv_SE"),
+            "sv_SE");
+  EXPECT_EQ(GetLocaleStringFromEnvironmentVariables(NULL, NULL, NULL, NULL),
+            nullptr);
+}
+
+TEST(FlutterGlfwTest, ParseLocaleSimple) {
+  std::string s = "en";
+  std::string language, territory, codeset, modifier;
+  ParseLocale(s, &language, &territory, &codeset, &modifier);
+  EXPECT_EQ(language, "en");
+  EXPECT_EQ(territory, "");
+  EXPECT_EQ(codeset, "");
+  EXPECT_EQ(modifier, "");
+}
+
+TEST(FlutterGlfwTest, ParseLocaleWithTerritory) {
+  std::string s = "en_GB";
+  std::string language, territory, codeset, modifier;
+  ParseLocale(s, &language, &territory, &codeset, &modifier);
+  EXPECT_EQ(language, "en");
+  EXPECT_EQ(territory, "GB");
+  EXPECT_EQ(codeset, "");
+  EXPECT_EQ(modifier, "");
+}
+
+TEST(FlutterGlfwTest, ParseLocaleWithCodeset) {
+  std::string s = "zh_CN.UTF-8";
+  std::string language, territory, codeset, modifier;
+  ParseLocale(s, &language, &territory, &codeset, &modifier);
+  EXPECT_EQ(language, "zh");
+  EXPECT_EQ(territory, "CN");
+  EXPECT_EQ(codeset, "UTF-8");
+  EXPECT_EQ(modifier, "");
+}
+
+TEST(FlutterGlfwTest, ParseLocaleFull) {
+  std::string s = "en_GB.ISO-8859-1@euro";
+  std::string language, territory, codeset, modifier;
+  ParseLocale(s, &language, &territory, &codeset, &modifier);
+  EXPECT_EQ(language, "en");
+  EXPECT_EQ(territory, "GB");
+  EXPECT_EQ(codeset, "ISO-8859-1");
+  EXPECT_EQ(modifier, "euro");
+}
+
+TEST(FlutterGlfwTest, GetLocalesSimple) {
+  const char* locale_string = "en_US";
+  std::list<std::string> locale_storage;
+
+  std::vector<std::unique_ptr<FlutterLocale>> locales =
+      GetLocales(locale_string, locale_storage);
+
+  EXPECT_EQ(locales.size(), 1UL);
+
+  EXPECT_STREQ(locales[0]->language_code, "en");
+  EXPECT_STREQ(locales[0]->country_code, "US");
+  EXPECT_STREQ(locales[0]->script_code, nullptr);
+  EXPECT_STREQ(locales[0]->variant_code, nullptr);
+}
+
+TEST(FlutterGlfwTest, GetLocalesFull) {
+  const char* locale_string = "en_GB.ISO-8859-1@euro:en_US:sv:zh_CN.UTF-8";
+  std::list<std::string> locale_storage;
+
+  std::vector<std::unique_ptr<FlutterLocale>> locales =
+      GetLocales(locale_string, locale_storage);
+
+  EXPECT_EQ(locales.size(), 4UL);
+
+  EXPECT_STREQ(locales[0]->language_code, "en");
+  EXPECT_STREQ(locales[0]->country_code, "GB");
+  EXPECT_STREQ(locales[0]->script_code, "ISO-8859-1");
+  EXPECT_STREQ(locales[0]->variant_code, "euro");
+
+  EXPECT_STREQ(locales[1]->language_code, "en");
+  EXPECT_STREQ(locales[1]->country_code, "US");
+  EXPECT_STREQ(locales[1]->script_code, nullptr);
+  EXPECT_STREQ(locales[1]->variant_code, nullptr);
+
+  EXPECT_STREQ(locales[2]->language_code, "sv");
+  EXPECT_STREQ(locales[2]->country_code, nullptr);
+  EXPECT_STREQ(locales[2]->script_code, nullptr);
+  EXPECT_STREQ(locales[2]->variant_code, nullptr);
+
+  EXPECT_STREQ(locales[3]->language_code, "zh");
+  EXPECT_STREQ(locales[3]->country_code, "CN");
+  EXPECT_STREQ(locales[3]->script_code, "UTF-8");
+  EXPECT_STREQ(locales[3]->variant_code, nullptr);
+}
+
+TEST(FlutterGlfwTest, GetLocalesEmpty) {
+  const char* locale_string = "";
+  std::list<std::string> locale_storage;
+
+  std::vector<std::unique_ptr<FlutterLocale>> locales =
+      GetLocales(locale_string, locale_storage);
+
+  EXPECT_EQ(locales.size(), 1UL);
+
+  EXPECT_STREQ(locales[0]->language_code, "C");
+  EXPECT_STREQ(locales[0]->country_code, nullptr);
+  EXPECT_STREQ(locales[0]->script_code, nullptr);
+  EXPECT_STREQ(locales[0]->variant_code, nullptr);
+}
+
+TEST(FlutterGlfwTest, GetLocalesNull) {
+  const char* locale_string;
+  std::list<std::string> locale_storage;
+
+  std::vector<std::unique_ptr<FlutterLocale>> locales =
+      GetLocales(locale_string, locale_storage);
+
+  EXPECT_EQ(locales.size(), 1UL);
+
+  EXPECT_STREQ(locales[0]->language_code, "C");
+  EXPECT_STREQ(locales[0]->country_code, nullptr);
+  EXPECT_STREQ(locales[0]->script_code, nullptr);
+  EXPECT_STREQ(locales[0]->variant_code, nullptr);
+}

testing/run_tests.py

@@ -158,6 +158,7 @@ def RunCCTests(build_dir, filter):
 
   if IsLinux():
     RunEngineExecutable(build_dir, 'flutter_linux_unittests', filter, shuffle_flags)
+    RunEngineExecutable(build_dir, 'flutter_glfw_unittests', filter, shuffle_flags)
 
 
 def RunEngineBenchmarks(build_dir, filter):