Applying Zap's memory leak changes & exposing escapeForRegexp.

Author: Simon Oxtoby

Diff for: src/AngularPublic.js

@@ -148,7 +148,8 @@ function publishExternalAPI(angular) {
     'getTestability': getTestability,
     '$$minErr': minErr,
     '$$csp': csp,
-    'reloadWithDebugInfo': reloadWithDebugInfo
+    'reloadWithDebugInfo': reloadWithDebugInfo,
+    'escapeForRegexp': escapeForRegexp
   });
 
   angularModule = setupModuleLoader(window);

Diff for: src/auto/injector.js

@@ -843,6 +843,26 @@ function createInjector(modulesToLoad, strictDi) {
       annotate: createInjector.$$annotate,
       has: function(name) {
         return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);
+      },
+
+      // V8LeakFix
+      dispose: function () {
+          var disposed = [];
+          cleanAndDispose(cache);
+          cleanAndDispose(providerCache);
+          disposed = undefined;
+
+          function cleanAndDispose(target) {
+              for (var p in target) {
+                  if (target.hasOwnProperty(p)) {
+                      if (p != '$injector' && target[p] && target[p].dispose && isFunction(target[p].dispose) && disposed.indexOf(target[p] == -1)) {
+                          disposed.push(target[p]);
+                          target[p].dispose();
+                      }
+                      delete target[p];
+                  }
+              }
+          }
       }
     };
   }

Diff for: src/ng/cacheFactory.js

@@ -347,6 +347,14 @@ function $CacheFactoryProvider() {
     };
 
 
+    // V8LeakFix
+    cacheFactory.dispose = function () {
+        for (var v in caches)
+            if (caches.hasOwnProperty(v))
+                caches[v].destroy();
+    }
+
+
     return cacheFactory;
   };
 }

Diff for: src/ng/http.js

@@ -1135,6 +1135,14 @@ function $HttpProvider() {
     $http.defaults = defaults;
 
 
+    // V8LeakFix
+    $http.dispose = function () {
+        for (var v in $http)
+            if ($http.hasOwnProperty(v))
+                delete $http[v];
+    };
+
+
     return $http;
 
 

Diff for: src/ng/parse.js

@@ -1711,7 +1711,7 @@ function $ParseProvider() {
           expensiveChecks: true
         };
 
-    return function $parse(exp, interceptorFn, expensiveChecks) {
+    function $parse(exp, interceptorFn, expensiveChecks) {
       var parsedExpression, oneTime, cacheKey;
 
       switch (typeof exp) {
@@ -1749,8 +1749,16 @@ function $ParseProvider() {
         default:
           return noop;
       }
+    }
+      
+    // V8LeakFix
+    $parse.dispose = function () {
+      cacheDefault = undefined;
+      cacheExpensive = undefined;
     };
 
+    return $parse;
+
     function expressionInputDirtyCheck(newValue, oldValueOfValue) {
 
       if (newValue == null || oldValueOfValue == null) { // null/undefined

Diff for: src/ng/rootScope.js

@@ -779,15 +779,16 @@ function $RootScopeProvider() {
                       lastDirtyWatch = watch;
                       watch.last = watch.eq ? copy(value, null) : value;
                       watch.fn(value, ((last === initWatchVal) ? value : last), current);
-                      if (ttl < 5) {
+                      // V8LeakFix
+                      /*if (ttl < 5) {
                         logIdx = 4 - ttl;
                         if (!watchLog[logIdx]) watchLog[logIdx] = [];
                         watchLog[logIdx].push({
                           msg: isFunction(watch.exp) ? 'fn: ' + (watch.exp.name || watch.exp.toString()) : watch.exp,
                           newVal: value,
                           oldVal: last
                         });
-                      }
+                      }*/
                     } else if (watch === lastDirtyWatch) {
                       // If the most recently dirty watcher is now clean, short circuit since the remaining watchers
                       // have already been tested.
@@ -873,6 +874,11 @@ function $RootScopeProvider() {
       $destroy: function() {
         // We can't destroy a scope that has been already destroyed.
         if (this.$$destroyed) return;
+
+        // V8LeakFix (recursively destroy child scopes)
+        while (this.$$childHead)
+          this.$$childHead.$destroy();
+
         var parent = this.$parent;
 
         this.$broadcast('$destroy');
@@ -908,6 +914,7 @@ function $RootScopeProvider() {
         // - https://github.com/angular/angular.js/issues/6794#issuecomment-38648909
         // - https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
 
+        this['this'] = this.$$ChildScope = // V8LeakFix
         this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead =
             this.$$childTail = this.$root = this.$$watchers = null;
       },

Diff for: src/ng/timeout.js

@@ -92,6 +92,15 @@ function $TimeoutProvider() {
       return false;
     };
 
+    // V8LeakFix
+    timeout.dispose = function () {
+      for (var p in deferreds)
+        if (deferreds.hasOwnProperty(p)) {
+          deferreds[p].reject('destroyed');
+          delete deferreds[p];
+        }
+    };
+
     return timeout;
   }];
 }