From 6b138db890e0f8a33127c7cfd10a56949ddf5510 Mon Sep 17 00:00:00 2001
From: ncuillery <nicolas.cuillery@gmail.com>
Date: Tue, 13 May 2014 10:41:22 +0200
Subject: [PATCH 1/3] fix($rootScope): avoid unstable reference in $broadcast
 event

The event.currentScope was a reference to the iterator of the scope traversal (`current`). It caused problems when accessing the event.currentScope asynchronously : it was the last scope of the traversal instead of the scope which listen the event.
---
 src/ng/rootScope.js      | 24 ++++++++++++++----------
 test/ng/rootScopeSpec.js |  1 +
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/ng/rootScope.js b/src/ng/rootScope.js
index 0936ef6a6a56..cc4aada2e95c 100644
--- a/src/ng/rootScope.js
+++ b/src/ng/rootScope.js
@@ -1096,23 +1096,25 @@ function $RootScopeProvider(){
        * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
        */
       $broadcast: function(name, args) {
+        function Event(currentScope) {
+          this.name = name;
+          this.currentScope = currentScope;
+          this.targetScope = target;
+          this.defaultPrevented = false;
+        }
+        Event.prototype.preventDefault = function() {
+          this.defaultPrevented = true;
+        }
+
         var target = this,
             current = target,
             next = target,
-            event = {
-              name: name,
-              targetScope: target,
-              preventDefault: function() {
-                event.defaultPrevented = true;
-              },
-              defaultPrevented: false
-            },
-            listenerArgs = concat([event], arguments, 1),
+            listenerArgs,
+            event = new Event(current),
             listeners, i, length;
 
         //down while you can, then up and next sibling or up and next sibling until back at root
         while ((current = next)) {
-          event.currentScope = current;
           listeners = current.$$listeners[name] || [];
           for (i=0, length = listeners.length; i<length; i++) {
             // if listeners were deregistered, defragment the array
@@ -1124,6 +1126,8 @@ function $RootScopeProvider(){
             }
 
             try {
+              event = new Event(current);
+              listenerArgs = concat([event], arguments, 1);
               listeners[i].apply(null, listenerArgs);
             } catch(e) {
               $exceptionHandler(e);
diff --git a/test/ng/rootScopeSpec.js b/test/ng/rootScopeSpec.js
index 3613869c0741..6794f01d0f54 100644
--- a/test/ng/rootScopeSpec.js
+++ b/test/ng/rootScopeSpec.js
@@ -1700,6 +1700,7 @@ describe('Scope', function() {
         it('should receive event object', inject(function($rootScope) {
           var scope = $rootScope,
               child = scope.$new(),
+              grandChild = child.$new(),
               event;
 
           child.$on('fooEvent', function(e) {

From 814f0e06cfa89b803b44696aa6b5097ea6c70a61 Mon Sep 17 00:00:00 2001
From: ncuillery <nicolas.cuillery@gmail.com>
Date: Tue, 13 May 2014 12:18:48 +0200
Subject: [PATCH 2/3] style: add missing semi-colon

---
 src/ng/rootScope.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ng/rootScope.js b/src/ng/rootScope.js
index cc4aada2e95c..84dee5b57a08 100644
--- a/src/ng/rootScope.js
+++ b/src/ng/rootScope.js
@@ -1104,7 +1104,7 @@ function $RootScopeProvider(){
         }
         Event.prototype.preventDefault = function() {
           this.defaultPrevented = true;
-        }
+        };
 
         var target = this,
             current = target,

From bd131bbbe004780880f942bc71a30fc1800738cb Mon Sep 17 00:00:00 2001
From: ncuillery <nicolas.cuillery@gmail.com>
Date: Thu, 15 May 2014 18:48:04 +0200
Subject: [PATCH 3/3] fix($rootScope): avoid unstable reference in $emit event

The event.currentScope in `$emit` method was a reference to an iterator. When accessing asynchronously, the event.currentScope was the $rootScope (end of the do/while loop) instead of the scope which listen the event.

The `$emit` and `$broadcast` methods use the same syntax now. Both methods are tested with :
- sync/async access to `event.currentScope` and `event.targetScope`.
- a test case for `preventDefault()` and `defaultPrevented`.
---
 src/ng/rootScope.js      | 38 +++++++++++++++++++++++++-------------
 test/ng/rootScopeSpec.js | 22 ++++++++++++++++++++--
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/src/ng/rootScope.js b/src/ng/rootScope.js
index 84dee5b57a08..a0f8f45d3969 100644
--- a/src/ng/rootScope.js
+++ b/src/ng/rootScope.js
@@ -1029,25 +1029,33 @@ function $RootScopeProvider(){
        * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}).
        */
       $emit: function(name, args) {
+        function Event(currentScope) {
+          this.name = name;
+          this.currentScope = currentScope;
+          this.targetScope = target;
+          this.defaultPrevented = globalDefaultPrevented;
+        }
+        Event.prototype.preventDefault = function() {
+          // Deals with the current instance (this) and also the next ones with globalDefaultPrevented.
+          this.defaultPrevented = true;
+          globalDefaultPrevented = true;
+        };
+        Event.prototype.stopPropagation = function() {
+          stopPropagation = true;
+        };
+
         var empty = [],
             namedListeners,
+            target = this,
             scope = this,
             stopPropagation = false,
-            event = {
-              name: name,
-              targetScope: scope,
-              stopPropagation: function() {stopPropagation = true;},
-              preventDefault: function() {
-                event.defaultPrevented = true;
-              },
-              defaultPrevented: false
-            },
-            listenerArgs = concat([event], arguments, 1),
+            globalDefaultPrevented = false,
+            event = new Event(scope),
+            listenerArgs,
             i, length;
 
         do {
           namedListeners = scope.$$listeners[name] || empty;
-          event.currentScope = scope;
           for (i=0, length=namedListeners.length; i<length; i++) {
 
             // if listeners were deregistered, defragment the array
@@ -1059,6 +1067,8 @@ function $RootScopeProvider(){
             }
             try {
               //allow all listeners attached to the current scope to run
+              event = new Event(scope);
+              listenerArgs = concat([event], arguments, 1);
               namedListeners[i].apply(null, listenerArgs);
             } catch (e) {
               $exceptionHandler(e);
@@ -1069,7 +1079,6 @@ function $RootScopeProvider(){
           //traverse upwards
           scope = scope.$parent;
         } while (scope);
-
         return event;
       },
 
@@ -1100,16 +1109,19 @@ function $RootScopeProvider(){
           this.name = name;
           this.currentScope = currentScope;
           this.targetScope = target;
-          this.defaultPrevented = false;
+          this.defaultPrevented = globalDefaultPrevented;
         }
         Event.prototype.preventDefault = function() {
+          // Deals with the current instance (this) and also the next ones with globalDefaultPrevented.
           this.defaultPrevented = true;
+          globalDefaultPrevented = true;
         };
 
         var target = this,
             current = target,
             next = target,
             listenerArgs,
+            globalDefaultPrevented = false,
             event = new Event(current),
             listeners, i, length;
 
diff --git a/test/ng/rootScopeSpec.js b/test/ng/rootScopeSpec.js
index 6794f01d0f54..daf131e802c5 100644
--- a/test/ng/rootScopeSpec.js
+++ b/test/ng/rootScopeSpec.js
@@ -1572,6 +1572,10 @@ describe('Scope', function() {
           });
           grandChild.$emit('myEvent');
           expect(event).toBeDefined();
+
+          // Asynchronous expectation : current & target should be the same as above
+          expect(event.targetScope).toBe(grandChild);
+          expect(event.currentScope).toBe(child);
         });
 
 
@@ -1693,6 +1697,18 @@ describe('Scope', function() {
           expect(result.name).toBe('some');
           expect(result.targetScope).toBe(child1);
         });
+
+        it('should have preventDefault method and defaultPrevented property', function() {
+          var event = child2.$broadcast('myEvent');
+          expect(event.defaultPrevented).toBe(false);
+
+          grandChild21.$on('myEvent', function(event) {
+            event.preventDefault();
+          });
+          event = child2.$broadcast('myEvent');
+          expect(event.defaultPrevented).toBe(true);
+        });
+
       });
 
 
@@ -1704,16 +1720,18 @@ describe('Scope', function() {
               event;
 
           child.$on('fooEvent', function(e) {
+            expect(e.targetScope).toBe(scope);
+            expect(e.currentScope).toBe(child);
+            expect(e.name).toBe('fooEvent');
             event = e;
           });
           scope.$broadcast('fooEvent');
 
-          expect(event.name).toBe('fooEvent');
+          // Asynchronous expectation : current & target should be the same as above
           expect(event.targetScope).toBe(scope);
           expect(event.currentScope).toBe(child);
         }));
 
-
         it('should support passing messages as varargs', inject(function($rootScope) {
           var scope = $rootScope,
               child = scope.$new(),