[i18n] $i18nPolymer to backslash escape

ui/base/template_expressions.cc

 // Copyright 2015 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 "ui/base/template_expressions.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "net/base/escape.h"
 
 namespace {
 const char kLeader[] = "$i18n";
 const size_t kLeaderSize = arraysize(kLeader) - 1;
 const char kKeyOpen = '{';
 const char kKeyClose = '}';
+
+// Escape quotes and backslashes ('"\) with backslashes.
+std::string BackslashEscape(const std::string& in_string) {
+  std::string out;
+  out.reserve(in_string.size() * 2);
+  for (const auto& c : in_string) {

[Dan Beam, 2017/02/14 00:25:54]

nit: a ref is probably bigger than a char

[dschuyler, 2017/02/14 00:38:35]

I expect that internally a ref uses several bytes -- as many as a pointer.
Though sizeof will still say that c is the the size of a char (1 byte).
I'm not sure what would be implied if it were bigger than a char (or whether the
internal physical size or the external logical size should be used for the
measurement). Is there something I should change?

[Dan Beam, 2017/02/14 00:58:46]

can you just do

for (const char c : in_string) {

isn't that likely to be smaller than a pointer-backed ref?

[dschuyler, 2017/02/14 02:30:12]

Done.

+    switch (c) {
+      case '\\':
+        out.append("\\\\");
+        break;
+      case '\'':
+        out.append("\\'");
+        break;
+      case '"':
+        out.append("\\\"");
+        break;
+      default:
+        out += c;
+    }
+  }
+  return out;
+}
+
 }  // namespace
 
 namespace ui {
 
 void TemplateReplacementsFromDictionaryValue(
     const base::DictionaryValue& dictionary,
     TemplateReplacements* replacements) {
   for (base::DictionaryValue::Iterator it(dictionary); !it.IsAtEnd();
        it.Advance()) {
     if (it.value().IsType(base::Value::Type::STRING)) {
@@ skipping 42 matching lines @@
     TemplateReplacements::const_iterator value = replacements.find(key);
     CHECK(value != replacements.end()) << "$i18n replacement key \"" << key
                                        << "\" not found";
 
     std::string replacement = value->second;
     if (context.empty()) {
       // Make the replacement HTML safe.
       replacement = net::EscapeForHTML(replacement);
     } else if (context == "Raw") {
       // Pass the replacement through unchanged.
+    } else if (context == "Polymer") {
+      // Escape quotes and backslash for '$i18nPolymer{}' use (i.e. quoted).
+      replacement = BackslashEscape(replacement);
     } else {
       CHECK(false) << "Unknown context " << context;
     }
 
     formatted.append(replacement);
 
     current_pos = key_end + sizeof(kKeyClose);
   }
   return formatted;
 }
 
 }  // namespace ui