Generate localizable strings in binary1 property list format.

ios/chrome/tools/strings/generate_localizable_strings.mm

 // Copyright 2016 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.
 
 // Helper tool that is built and run during a build to pull strings from the
 // GRD files and generate a localized string files needed for iOS app bundles.
 // Arguments:
 //   -p dir_to_data_pak
 //   -o output_dir
 //   -c config_file
@@ skipping 70 matching lines @@
                                    encoding:NSUTF8StringEncoding] autorelease];
   } else if (data_pack.GetTextEncodingType() == ui::DataPack::UTF16) {
     return [[[NSString alloc] initWithBytes:data.data()
                                      length:data.length()
                                    encoding:NSUTF16LittleEndianStringEncoding]
         autorelease];
   }
   return nil;
 }
 
-NSString* EscapeStringForLocalizableStrings(NSString* string) {
-  NSString* slashEscapedString =
-      [string stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"];
-  return [slashEscapedString stringByReplacingOccurrencesOfString:@"\""
-                                                       withString:@"\\\""];
-}
-
-// Generate the content of the Localizable.string file for |locale| from the
-// resource data pack |data_pack|. The content should have the format of:
-//   "IDS_PRINT_TO_PHONE" = "Print to phone jobs are available.";
-//   "IDS_SNAPSHOTS" = "Snapshots are available.";
-NSString* GenerateLocalizableStringsFileContent(const ui::DataPack& data_pack,
-                                                const char* locale,
-                                                NSArray* resources,
-                                                NSDictionary* resources_ids) {
-  NSMutableString* localizable_strings = [NSMutableString string];
+// Generates a NSDictionary mapping string IDs to localized strings. The
+// dictionary can be written as a Property List (only contains types that
+// are valid in Propery Lists).
+NSDictionary* GenerateLocalizableStringsDictionary(
+    const ui::DataPack& data_pack,
+    const char* locale,
+    NSArray* resources,
+    NSDictionary* resources_ids) {
+  NSMutableDictionary* dictionary = [NSMutableDictionary dictionary];
   for (id resource : resources) {
     NSString* resource_name = nil;
     NSString* resource_output_name = nil;
     if ([resource isKindOfClass:[NSString class]]) {
       resource_name = resource;
       resource_output_name = resource;
     } else if ([resource isKindOfClass:[NSDictionary class]]) {
       resource_name = [resource objectForKey:@"input"];
       resource_output_name = [resource objectForKey:@"output"];
       if (!resource_name || !resource_output_name) {
         fprintf(
             stderr,
             "ERROR: resources must be given in <string> or <dict> format.\n");
         return nil;
       }
     } else {
       fprintf(stderr,
               "ERROR: resources must be given in <string> or <dict> format.\n");
       return nil;
     }
     NSInteger resource_id =
         [[resources_ids objectForKey:resource_name] integerValue];
     NSString* string = GetStringFromDataPack(data_pack, resource_id);
     if (string) {
-      const char* output_string_name = [resource_output_name UTF8String];
-      [localizable_strings
-          appendFormat:@" \"%s\" = \"%@\";\n", output_string_name,
-                       EscapeStringForLocalizableStrings(string)];
+      [dictionary setObject:string forKey:resource_output_name];
     } else {
       fprintf(stderr, "ERROR: fail to load string '%s' for locale '%s'\n",
               [resource_name UTF8String], locale);
       return nil;
     }
   }
 
-  return localizable_strings;
+  return dictionary;
 }
 
 NSDictionary* LoadResourcesListFromHeaders(NSArray* header_list,
                                            NSString* root_header_dir) {
   if (![header_list count]) {
     fprintf(stderr, "ERROR: No header file in the config.\n");
     return nil;
   }
   NSMutableDictionary* resources_ids =
       [[[NSMutableDictionary alloc] init] autorelease];
@@ skipping 39 matching lines @@
                 [string_name UTF8String]);
         return nil;
       }
       [resources_ids setValue:[NSNumber numberWithInteger:string_id]
                        forKey:string_name];
     }
   }
   return resources_ids;
 }
 
-// Save |localizable_strings| with |locale| to
-// |output_dir|/|locale|.lproj/|output_filename|.
-bool SaveLocalizableFile(NSString* localizable_strings,
-                         NSString* locale,
-                         NSString* output_dir,
-                         NSString* output_filename) {
+// Save |dictionary| as a Property List file (in binary1 encoding)
+// with |locale| to |output_dir|/|locale|.lproj/|output_filename|.
+bool SavePropertyList(NSDictionary* dictionary,
+                      NSString* locale,
+                      NSString* output_dir,
+                      NSString* output_filename) {
   // Compute the path to the output directory with locale.
   NSString* output_path = [output_dir
       stringByAppendingPathComponent:[NSString
                                          stringWithFormat:@"%@.lproj", locale]];
 
   // Prepare the directory.
   NSFileManager* file_manager = [NSFileManager defaultManager];
   if (![file_manager fileExistsAtPath:output_path] &&
       ![file_manager createDirectoryAtPath:output_path
                withIntermediateDirectories:YES
                                 attributes:nil
                                      error:nil]) {
     fprintf(stderr, "ERROR: '%s' didn't exist or failed to create it\n",
             [output_path UTF8String]);
     return false;
   }
 
+  // Convert to property list in binary format.
+  NSError* error = nil;
+  NSData* data = [NSPropertyListSerialization
+      dataWithPropertyList:dictionary
+                    format:NSPropertyListBinaryFormat_v1_0
+                   options:0
+                     error:&error];
+  if (!data) {
+    fprintf(stderr, "ERROR: conversion to property list failed: %s\n",
+            [[error localizedDescription] UTF8String]);
+    return false;
+  }
+
   // Save the strings to the disk.
   output_path = [output_path stringByAppendingPathComponent:output_filename];
-  if (![localizable_strings writeToFile:output_path
-                             atomically:YES
-                               encoding:NSUTF16StringEncoding
-                                  error:nil]) {
+  if (![data writeToFile:output_path atomically:YES]) {
     fprintf(stderr, "ERROR: Failed to write out '%s'\n",
             [output_filename UTF8String]);
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
@@ skipping 110 matching lines @@
         fprintf(stderr, "ERROR: Output without name.\n");
         exit(1);
       }
       NSArray* output_strings = [output objectForKey:@"strings"];
       if (![output_strings count]) {
         fprintf(stderr, "ERROR: Output without strings: %s.\n",
                 [output_name UTF8String]);
         exit(1);
       }
 
-      NSString* localizable_strings = GenerateLocalizableStringsFileContent(
+      NSDictionary* dictionary = GenerateLocalizableStringsDictionary(
           *data_pack, [locale UTF8String], output_strings, resources_ids);
-      if (localizable_strings) {
-        SaveLocalizableFile(localizable_strings, locale, output_dir,
-                            output_name);
+      if (dictionary) {
+        SavePropertyList(dictionary, locale, output_dir, output_name);
       } else {
         fprintf(stderr, "ERROR: Unable to create %s.\n",
                 [output_name UTF8String]);
         exit(1);
       }
     }
   }
   return 0;
 }