fix($interpolate): always unescape escaped interpolation markers

Previously, whenever `mustHaveExpression` was true (e.g. when compiling a text nodes),
`$interpolate` would not unescape the escaped interpolation markers if there were no actual
interpolation expressionsin the same string.
This commit fixes the problem, by always unescaping the escaped markers (if any).

Due to always checking for the presence of escaped interpolation markers, there is a slight
performance hit.

Fixes angular#14196

Author: gkalpak

Diff for: src/ng/interpolate.js

@@ -97,12 +97,19 @@ function $InterpolateProvider() {
 
 
   this.$get = ['$parse', '$exceptionHandler', '$sce', function($parse, $exceptionHandler, $sce) {
-    var startSymbolLength = startSymbol.length,
+    var EVERY_CHAR = /./g,
+        startSymbolLength = startSymbol.length,
         endSymbolLength = endSymbol.length,
-        escapedStartRegexp = new RegExp(startSymbol.replace(/./g, escape), 'g'),
-        escapedEndRegexp = new RegExp(endSymbol.replace(/./g, escape), 'g');
+        escapedStartSymbol = startSymbol.replace(EVERY_CHAR, escapeForString),
+        escapedEndSymbol = endSymbol.replace(EVERY_CHAR, escapeForString),
+        escapedStartRegexp = new RegExp(startSymbol.replace(EVERY_CHAR, escapeForRegex), 'g'),
+        escapedEndRegexp = new RegExp(endSymbol.replace(EVERY_CHAR, escapeForRegex), 'g');
 
-    function escape(ch) {
+    function escapeForString(ch) {
+      return '\\' + ch;
+    }
+
+    function escapeForRegex(ch) {
       return '\\\\\\' + ch;
     }
 
@@ -232,10 +239,13 @@ function $InterpolateProvider() {
      * - `context`: evaluation context for all expressions embedded in the interpolated text
      */
     function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) {
+      var hasEscapedMarkers = text.length &&
+          (text.indexOf(escapedStartSymbol) !== -1 || text.indexOf(escapedEndSymbol) !== -1);
+
       // Provide a quick exit and simplified result function for text with no interpolation
       if (!text.length || text.indexOf(startSymbol) === -1) {
         var constantInterp;
-        if (!mustHaveExpression) {
+        if (!mustHaveExpression || hasEscapedMarkers) {
           var unescapedText = unescapeText(text);
           constantInterp = valueFn(unescapedText);
           constantInterp.exp = text;
@@ -257,8 +267,8 @@ function $InterpolateProvider() {
           expressionPositions = [];
 
       while (index < textLength) {
-        if (((startIndex = text.indexOf(startSymbol, index)) != -1) &&
-             ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1)) {
+        if (((startIndex = text.indexOf(startSymbol, index)) !== -1) &&
+            ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) !== -1)) {
           if (index !== startIndex) {
             concat.push(unescapeText(text.substring(index, startIndex)));
           }
@@ -332,6 +342,12 @@ function $InterpolateProvider() {
             });
           }
         });
+      } else if (hasEscapedMarkers) {
+        return extend(valueFn(unescapeText(text)), {
+          exp: text,
+          expressions: [],
+          $$watchDelegate: constantWatchDelegate
+        });
       }
 
       function parseStringifyInterceptor(value) {

Diff for: test/ng/interpolateSpec.js

@@ -200,6 +200,47 @@ describe('$interpolate', function() {
     }));
 
 
+    it('should always unescape markers in uninterpolated strings', inject(function($interpolate) {
+        // Exercise the "quick exit" path
+        expect($interpolate('\\{\\{foo\\}\\}', false)(obj)).toBe('{{foo}}');
+        expect($interpolate('\\{\\{foo\\}\\}', true)(obj)).toBe('{{foo}}');
+
+        // Exercise the "slow" path, where we can't immediately tell that there are no expressions
+        expect($interpolate('}}{{\\{\\{foo\\}\\}', false)(obj)).toBe('}}{{{{foo}}');
+        expect($interpolate('}}{{\\{\\{foo\\}\\}', true)(obj)).toBe('}}{{{{foo}}');
+      })
+    );
+
+
+    it('should always unescape custom markers in uninterpolated strings', function() {
+      module(function($interpolateProvider) {
+        $interpolateProvider.startSymbol('[[');
+        $interpolateProvider.endSymbol(']]');
+      });
+      inject(function($interpolate) {
+        // Exercise the "quick exit" path
+        expect($interpolate('\\[\\[foo\\]\\]', false)(obj)).toBe('[[foo]]');
+        expect($interpolate('\\[\\[foo\\]\\]', true)(obj)).toBe('[[foo]]');
+
+        // Exercise the "slow" path, where we can't immediately tell that there are no expressions
+        expect($interpolate(']][[\\[\\[foo\\]\\]', false)(obj)).toBe(']][[[[foo]]');
+        expect($interpolate(']][[\\[\\[foo\\]\\]', true)(obj)).toBe(']][[[[foo]]');
+      });
+    });
+
+
+    it('should not interpolate escaped expressions after unescaping',
+      inject(function($compile, $rootScope) {
+        var elem = $compile('<div>\\{\\{foo\\}\\}</div>')($rootScope);
+        $rootScope.foo = 'bar';
+        $rootScope.$digest();
+        $rootScope.$digest();
+
+        expect(elem.text()).toBe('{{foo}}');
+      })
+    );
+
+
     // This test demonstrates that the web-server is responsible for escaping every single instance
     // of interpolation start/end markers in an expression which they do not wish to evaluate,
     // because AngularJS will not protect them from being evaluated (due to the added complexity