Auto-generates the font family scripts at build time.

chrome/common/font_family_scripts_generator.cc

Index: chrome/common/font_family_scripts_generator.cc
diff --git a/chrome/common/font_family_scripts_generator.cc b/chrome/common/font_family_scripts_generator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5ffb95ed09e61ca6226cb49e2b8f1dccb568ed46
--- /dev/null
+++ b/chrome/common/font_family_scripts_generator.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2013 The Chromium 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 <stdio.h>
+
+#include <string>
+
+#include "chrome/common/pref_names.h"
+
+// A simple executable to auto-generate a header file used by
+// prefs_tab_helper.cc. This avoids the string-construction and heap allocation
+// at startup time by using RO data section.

[Bernhard Bauer, 2013/03/19 14:44:51]

Is there any reason you're doing this in C++ instead of a scripting language,
i.e. Python?

Alternatively, how about using some preprocessing trickery?

[bulach, 2013/03/19 15:35:16]

yeah, I wished I could do a script.. :)
the reason for using c++ is that the values are actually defined in
pref_names.cc, so anything but c++ would end up pretty convoluted.. :-/

for the same reason, there's no easy way to use pre-processing tricks, unless of
course we move the data out of pref_names.cc.. I can certainly try that if you
thing it's worth it? it'd probably require a header file without guards in order
to allow multiple pass, etc.., so it may end up less readable and harder to
maintain than this.. wdyt?

[Bernhard Bauer, 2013/03/19 16:06:38]

Hm... how about the following:

#define DEFINE_FONT_PREF_NAMES(script_name)       \
  "webkit.webprefs.fonts.standard." script_name,  \
  "webkit.webprefs.fonts.fixed." script_name,     \
  // ...
  "webkit.webprefs.fonts.pictograph." script_name

const char* const kWebKitScriptsForFontFamilyMaps[] = {
  DEFINE_FONT_PREF_NAMES("Afak"),
  DEFINE_FONT_PREF_NAMES("Arab"),
  // ...
  DEFINE_FONT_PREF_NAMES("Xyzzy"),
};

We could also pull the prefixes out into #define's to avoid repeating them (they
would need to be #define's instead of constants so we can use them in the macro,
but I don't think that would be too bad).

[bulach, 2013/03/19 16:18:17]

the problem is that the "Afak", "Arab", ... "Xyzzy" is 152 long, so we
definitely want to avoid repeating them as well.. 
but pulling out all of those is a good idea, thanks!

let me try that and see how it goes, will update this patch in a bit..

+void UnrollMap(FILE* f, const char* map_name) {
+  for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
+    const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
+    fprintf(f, "\"%s.%s\",\n", map_name, script);
+  }
+}
+
+void GenerateMap(FILE* f) {
+  static const char* const kMaps[] = {
+    prefs::kWebKitStandardFontFamilyMap,
+    prefs::kWebKitFixedFontFamilyMap,
+    prefs::kWebKitSerifFontFamilyMap,
+    prefs::kWebKitSansSerifFontFamilyMap,
+    prefs::kWebKitCursiveFontFamilyMap,
+    prefs::kWebKitFantasyFontFamilyMap,
+    prefs::kWebKitPictographFontFamilyMap,
+  };
+
+  fprintf(f, "static const char* const kFontFamilyScripts[] =  {\n");
+  for (size_t i = 0; i < sizeof(kMaps) / sizeof(kMaps[0]); ++i)
+    UnrollMap(f, kMaps[i]);
+  fprintf(f, "};\n");
+}
+
+int main(int argc, char** argv) {
+  FILE* f = argc < 2 ? stdout : fopen(argv[1], "w");
+  GenerateMap(f);
+  return 0;
+}