[MD Bookmarks] Support elision of bookmark names in the bookmark toast.

ui/webui/resources/js/load_time_data.js

 // Copyright (c) 2012 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.
 
 /**
  * @fileoverview This file defines a singleton which provides access to all data
  * that is available as soon as the page's resources are loaded (before DOM
  * content has finished loading). This data includes both localized strings and
  * any data that is important to have ready from a very early stage (e.g. things
  * that must be displayed right away).
@@ skipping 76 matching lines @@
       if (!value)
         return '';
 
       var varArgs = arguments;
       return value.replace(/\$[$1-9]/g, function(m) {
         return m == '$$' ? '$' : varArgs[m[1]];
       });
     },
 
     /**
+     * Returns a list of pieces of a substituted string which has separate

[tsergeant, 2017/06/05 03:33:54]

This is a fairly complex function with a bunch of opaque regex operations, so it
would be nice to more fully explain what's going on here. Eg,

Returns a formatted string where $1 to $9 are replaced by the second to tenth
argument, split apart into a list of pieces describing how the substitution was
performed.

[calamity, 2017/06/06 05:36:02]

Done.

+     * elements for substituted pieces.
+     * @param {string} label

[tsergeant, 2017/06/05 03:33:54]

Add a comment here to explicitly say that this is a string and not a string ID.

[calamity, 2017/06/06 05:36:02]

Done.

+     * @param {...(string|number)} var_args The extra values to include in the
+     *     formatted output.
+     * @return {!Array<!{value: string, arg: (null|string)}>} The formatted
+     *     string.
+     */
+    getSubstitutedStringPieces: function(label, var_args) {
+      var varArgs = arguments;
+      var pieces = label.split(/(?=[^$]?)(\$[1-9])/)

[tsergeant, 2017/06/05 03:33:54]

Why is the positive lookahead here?

It says something like "optionally match something that is not a dollar sign,
but don't consume it if you do match it", which seems to amount to...never
actually doing anything

[calamity, 2017/06/06 05:36:02]

Yeah, good point. Okay. I've revised this. We need to catch cases such as $$60
which should render as $60. Tests also updated to catch this case.

The current regex says:
Match $1-9
(\$[1-9])

or
|

Match 1 or more (non $ characters or ($ followed by non 1-9 or EOS))
(([^$]|\$([^1-9]|$))+)

+                       .filter(function(p) {
+                         return p != '';
+                       })
+                       .map(function(p) {
+                         if (!p.match(/\$[1-9]/)) {
+                           // Assert if there are an odd number of $ signs in
+                           // the segment.
+                           assert((p.match(/\$/g) || []).length % 2 == 0);

[tsergeant, 2017/06/05 03:33:54]

This assertion makes getSubstitutedStringPieces() more restrictive than
getStringF() above.

Where this function requires every $ to be escaped, getStringF() only requires
escaping for things like $1.

It would be nice if we could converge the two checks so that both functions
behave the same (I prefer the getStringF() version, but there's not much
difference).

[calamity, 2017/06/06 05:36:02]

Done. Went with 'all $ must be escaped' and added tests. I think the consistency
of escaping $ is nice and asserting will help catch mistakes. In any case,
AFAIK, this escaping never comes up (there are no floating $ signs in chrome).

Also added testing for ensuring that getStringF and this function return the
same string when joined.

+                           return {value: p.replace(/\$\$/g, '$'), arg: null};
+                         }
+
+                         return {value: varArgs[p[1]], arg: p};
+                       });
+
+      return pieces;
+    },
+
+    /**
      * As above, but also makes sure that the value is a boolean.
      * @param {string} id The key that identifies the desired boolean.
      * @return {boolean} The corresponding boolean value.
      */
     getBoolean: function(id) {
       var value = this.getValue(id);
       expectIsType(id, value, 'boolean');
       return /** @type {boolean} */ (value);
     },
 
@@ skipping 42 matching lines @@
    * @param {string} type The type we expect |value| to be.
    */
   function expectIsType(id, value, type) {
     expect(
         typeof value == type, '[' + value + '] (' + id + ') is not a ' + type);
   }
 
   expect(!loadTimeData, 'should only include this file once');
   loadTimeData = new LoadTimeData;
 })();