diff --git a/docs/content/cookbook/deeplinking.ngdoc b/docs/content/cookbook/deeplinking.ngdoc
index 491e3b799a7d..1e9c01616cfe 100644
--- a/docs/content/cookbook/deeplinking.ngdoc
+++ b/docs/content/cookbook/deeplinking.ngdoc
@@ -35,8 +35,8 @@ In this example we have a simple app which consist of two screens:
    angular.module('deepLinking', ['ngSanitize'])
      .config(function($routeProvider) {
         $routeProvider.
-          when("/welcome",  {template:'welcome.html',  controller:WelcomeCntl}).
-          when("/settings", {template:'settings.html', controller:SettingsCntl});
+          when("/welcome",  {templateUrl:'welcome.html',  controller:WelcomeCntl}).
+          when("/settings", {templateUrl:'settings.html', controller:SettingsCntl});
      });
 
    AppCntl.$inject = ['$scope', '$route']
diff --git a/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc b/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
index bccc653930a5..01c261469a57 100644
--- a/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
+++ b/docs/content/guide/dev_guide.services.managing_dependencies.ngdoc
@@ -76,7 +76,7 @@ provided by Angular's web framework:
     $provide.factory('routeTemplateMonitor',
                 ['$route', 'batchLog', '$rootScope',
          function($route,   batchLog,   $rootScope) {
-      $rootScope.$on('$afterRouteChange', function() {
+      $rootScope.$on('$routeChangeSuccess', function() {
         batchLog($route.current ? $route.current.template : null);
       });
     }]);
diff --git a/docs/content/tutorial/step_07.ngdoc b/docs/content/tutorial/step_07.ngdoc
index f8b5cf527072..f0812278445e 100644
--- a/docs/content/tutorial/step_07.ngdoc
+++ b/docs/content/tutorial/step_07.ngdoc
@@ -72,8 +72,8 @@ __`app/js/app.js`:__
 angular.module('phonecat', []).
   config(['$routeProvider', function($routeProvider) {
   $routeProvider.
-      when('/phones', {template: 'partials/phone-list.html',   controller: PhoneListCtrl}).
-      when('/phones/:phoneId', {template: 'partials/phone-detail.html', controller: PhoneDetailCtrl}).
+      when('/phones', {templateUrl: 'partials/phone-list.html',   controller: PhoneListCtrl}).
+      when('/phones/:phoneId', {templateUrl: 'partials/phone-detail.html', controller: PhoneDetailCtrl}).
       otherwise({redirectTo: '/phones'});
 }]);
 </pre>
diff --git a/docs/src/ngdoc.js b/docs/src/ngdoc.js
index 6576e6193cad..70884b8f7c2e 100644
--- a/docs/src/ngdoc.js
+++ b/docs/src/ngdoc.js
@@ -54,7 +54,7 @@ Doc.prototype = {
     function extractWords(text) {
       var tokens = text.toLowerCase().split(/[,\.\`\'\"\#\s]+/mg);
       tokens.forEach(function(key){
-        var match = key.match(/^(([\$\_a-z]|ng\:)[\w\_\-]{2,})/);
+        var match = key.match(/^(([\$\_a-z]|ng\:)[\w\_\-]+)/);
         if (match){
           key = match[1];
           if (!keywords[key]) {
diff --git a/example/temp.html b/example/temp.html
index 22eb2de7da31..da92c68ccf3c 100644
--- a/example/temp.html
+++ b/example/temp.html
@@ -6,8 +6,8 @@
     <script>
       setupModuleLoader(window);
       angular.module('example', [], function($routeProvider) {
-        $routeProvider.when('/view1', {controller: MyCtrl, template: 'view1.html'});
-        $routeProvider.when('/view2', {controller: MyCtrl, template: 'view2.html'});
+        $routeProvider.when('/view1', {controller: MyCtrl, templateUrl: 'view1.html'});
+        $routeProvider.when('/view2', {controller: MyCtrl, templateUrl: 'view2.html'});
 
         function MyCtrl($location, $scope) {
           $scope.url = function() {
diff --git a/src/Angular.js b/src/Angular.js
index 86689c0b0b98..7c87cfd975be 100644
--- a/src/Angular.js
+++ b/src/Angular.js
@@ -913,10 +913,13 @@ function angularInit(element, bootstrap) {
 function bootstrap(element, modules) {
   element = jqLite(element);
   modules = modules || [];
+  modules.unshift(['$provide', function($provide) {
+    $provide.value('$rootElement', element);
+  }]);
   modules.unshift('ng');
   var injector = createInjector(modules);
   injector.invoke(
-    ['$rootScope', '$compile', '$injector', function(scope, compile, injector){
+    ['$rootScope', '$rootElement', '$compile', '$injector', function(scope, element, compile, injector){
       scope.$apply(function() {
         element.data('$injector', injector);
         compile(element)(scope);
diff --git a/src/auto/injector.js b/src/auto/injector.js
index 250f05c5b826..49247ff4ee2a 100644
--- a/src/auto/injector.js
+++ b/src/auto/injector.js
@@ -42,19 +42,32 @@ var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
 var FN_ARG_SPLIT = /,/;
 var FN_ARG = /^\s*(_?)(.+?)\1\s*$/;
 var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-function inferInjectionArgs(fn) {
-  assertArgFn(fn);
-  if (!fn.$inject) {
-    var args = fn.$inject = [];
-    var fnText = fn.toString().replace(STRIP_COMMENTS, '');
-    var argDecl = fnText.match(FN_ARGS);
-    forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){
-      arg.replace(FN_ARG, function(all, underscore, name){
-        args.push(name);
+function annotate(fn) {
+  var $inject,
+      fnText,
+      argDecl,
+      last;
+
+  if (typeof fn == 'function') {
+    if (!($inject = fn.$inject)) {
+      $inject = [];
+      fnText = fn.toString().replace(STRIP_COMMENTS, '');
+      argDecl = fnText.match(FN_ARGS);
+      forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){
+        arg.replace(FN_ARG, function(all, underscore, name){
+          $inject.push(name);
+        });
       });
-    });
+      fn.$inject = $inject;
+    }
+  } else if (isArray(fn)) {
+    last = fn.length - 1;
+    assertArgFn(fn[last], 'fn')
+    $inject = fn.slice(0, last);
+  } else {
+    assertArgFn(fn, 'fn', true);
   }
-  return fn.$inject;
+  return $inject;
 }
 
 ///////////////////////////////////////
@@ -152,6 +165,87 @@ function inferInjectionArgs(fn) {
  * @returns {Object} new instance of `Type`.
  */
 
+/**
+ * @ngdoc method
+ * @name angular.module.AUTO.$injector#annotate
+ * @methodOf angular.module.AUTO.$injector
+ *
+ * @description
+ * Returns an array of service names which the function is requesting for injection. This API is used by the injector
+ * to determine which services need to be injected into the function when the function is invoked. There are three
+ * ways in which the function can be annotated with the needed dependencies.
+ *
+ * # Argument names
+ *
+ * The simplest form is to extract the dependencies from the arguments of the function. This is done by converting
+ * the function into a string using `toString()` method and extracting the argument names.
+ * <pre>
+ *   // Given
+ *   function MyController($scope, $route) {
+ *     // ...
+ *   }
+ *
+ *   // Then
+ *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+ * </pre>
+ *
+ * This method does not work with code minfication / obfuscation. For this reason the following annotation strategies
+ * are supported.
+ *
+ * # The `$injector` property
+ *
+ * If a function has an `$inject` property and its value is an array of strings, then the strings represent names of
+ * services to be injected into the function.
+ * <pre>
+ *   // Given
+ *   var MyController = function(obfuscatedScope, obfuscatedRoute) {
+ *     // ...
+ *   }
+ *   // Define function dependencies
+ *   MyController.$inject = ['$scope', '$route'];
+ *
+ *   // Then
+ *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+ * </pre>
+ *
+ * # The array notation
+ *
+ * It is often desirable to inline Injected functions and that's when setting the `$inject` property is very
+ * inconvenient. In these situations using the array notation to specify the dependencies in a way that survives
+ * minification is a better choice:
+ *
+ * <pre>
+ *   // We wish to write this (not minification / obfuscation safe)
+ *   injector.invoke(function($compile, $rootScope) {
+ *     // ...
+ *   });
+ *
+ *   // We are forced to write break inlining
+ *   var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
+ *     // ...
+ *   };
+ *   tmpFn.$inject = ['$compile', '$rootScope'];
+ *   injector.invoke(tempFn);
+ *
+ *   // To better support inline function the inline annotation is supported
+ *   injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
+ *     // ...
+ *   }]);
+ *
+ *   // Therefore
+ *   expect(injector.annotate(
+ *      ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
+ *    ).toEqual(['$compile', '$rootScope']);
+ * </pre>
+ *
+ * @param {function|Array.<string|Function>} fn Function for which dependent service names need to be retrieved as described
+ *   above.
+ *
+ * @returns {Array.<string>} The names of the services which the function requires.
+ */
+
+
+
 
 /**
  * @ngdoc object
@@ -454,23 +548,11 @@ function createInjector(modulesToLoad) {
 
     function invoke(fn, self, locals){
       var args = [],
-          $inject,
-          length,
+          $inject = annotate(fn),
+          length, i,
           key;
 
-      if (typeof fn == 'function') {
-        $inject = inferInjectionArgs(fn);
-        length = $inject.length;
-      } else {
-        if (isArray(fn)) {
-          $inject = fn;
-          length = $inject.length - 1;
-          fn = $inject[length];
-        }
-        assertArgFn(fn, 'fn');
-      }
-
-      for(var i = 0; i < length; i++) {
+      for(i = 0, length = $inject.length; i < length; i++) {
         key = $inject[i];
         args.push(
           locals && locals.hasOwnProperty(key)
@@ -478,6 +560,11 @@ function createInjector(modulesToLoad) {
           : getService(key, path)
         );
       }
+      if (!fn.$inject) {
+        // this means that we must be an array.
+        fn = fn[length];
+      }
+
 
       // Performance optimization: http://jsperf.com/apply-vs-call-vs-invoke
       switch (self ? -1 : args.length) {
@@ -510,7 +597,8 @@ function createInjector(modulesToLoad) {
     return {
       invoke: invoke,
       instantiate: instantiate,
-      get: getService
+      get: getService,
+      annotate: annotate
     };
   }
 }
diff --git a/src/bootstrap/bootstrap-prettify.js b/src/bootstrap/bootstrap-prettify.js
index e7fc1e9e6a42..a4eb52f242e7 100644
--- a/src/bootstrap/bootstrap-prettify.js
+++ b/src/bootstrap/bootstrap-prettify.js
@@ -190,7 +190,12 @@ directive.ngEmbedApp = ['$templateCache', '$browser', '$rootScope', '$location',
         $provide.value('$anchorScroll', angular.noop);
         $provide.value('$browser', $browser);
         $provide.provider('$location', function() {
-          this.$get = function() { return $location; };
+          this.$get = ['$rootScope', function($rootScope) {
+            docsRootScope.$on('$locationChangeSuccess', function(event, oldUrl, newUrl) {
+              $rootScope.$broadcast('$locationChangeSuccess', oldUrl, newUrl);
+            });
+            return $location;
+          }];
           this.html5Mode = angular.noop;
         });
         $provide.decorator('$defer', ['$rootScope', '$delegate', function($rootScope, $delegate) {
diff --git a/src/ng/directive/ngView.js b/src/ng/directive/ngView.js
index 7c7377653b40..286468222960 100644
--- a/src/ng/directive/ngView.js
+++ b/src/ng/directive/ngView.js
@@ -49,11 +49,11 @@
       <file name="script.js">
         angular.module('ngView', [], function($routeProvider, $locationProvider) {
           $routeProvider.when('/Book/:bookId', {
-            template: 'book.html',
+            templateUrl: 'book.html',
             controller: BookCntl
           });
           $routeProvider.when('/Book/:bookId/ch/:chapterId', {
-            template: 'chapter.html',
+            templateUrl: 'chapter.html',
             controller: ChapterCntl
           });
 
@@ -112,11 +112,10 @@ var ngViewDirective = ['$http', '$templateCache', '$route', '$anchorScroll', '$c
     restrict: 'ECA',
     terminal: true,
     link: function(scope, element, attr) {
-      var changeCounter = 0,
-          lastScope,
+      var lastScope,
           onloadExp = attr.onload || '';
 
-      scope.$on('$afterRouteChange', update);
+      scope.$on('$routeChangeSuccess', update);
       update();
 
 
@@ -127,43 +126,36 @@ var ngViewDirective = ['$http', '$templateCache', '$route', '$anchorScroll', '$c
         }
       }
 
+      function clearContent() {
+        element.html('');
+        destroyLastScope();
+      }
+
       function update() {
-        var template = $route.current && $route.current.template,
-            thisChangeId = ++changeCounter;
-
-        function clearContent() {
-          // ignore callback if another route change occured since
-          if (thisChangeId === changeCounter) {
-            element.html('');
-            destroyLastScope();
-          }
-        }
+        var locals = $route.current && $route.current.locals,
+            template = locals && locals.$template;
 
         if (template) {
-          $http.get(template, {cache: $templateCache}).success(function(response) {
-            // ignore callback if another route change occured since
-            if (thisChangeId === changeCounter) {
-              element.html(response);
-              destroyLastScope();
-
-              var link = $compile(element.contents()),
-                  current = $route.current,
-                  controller;
-
-              lastScope = current.scope = scope.$new();
-              if (current.controller) {
-                controller = $controller(current.controller, {$scope: lastScope});
-                element.contents().data('$ngControllerController', controller);
-              }
-
-              link(lastScope);
-              lastScope.$emit('$viewContentLoaded');
-              lastScope.$eval(onloadExp);
-
-              // $anchorScroll might listen on event...
-              $anchorScroll();
-            }
-          }).error(clearContent);
+          element.html(template);
+          destroyLastScope();
+
+          var link = $compile(element.contents()),
+              current = $route.current,
+              controller;
+
+          lastScope = current.scope = scope.$new();
+          if (current.controller) {
+            locals.$scope = lastScope;
+            controller = $controller(current.controller, locals);
+            element.contents().data('$ngControllerController', controller);
+          }
+
+          link(lastScope);
+          lastScope.$emit('$viewContentLoaded');
+          lastScope.$eval(onloadExp);
+
+          // $anchorScroll might listen on event...
+          $anchorScroll();
         } else {
           clearContent();
         }
diff --git a/src/ng/location.js b/src/ng/location.js
index 54abf6cb3988..64a234ad5588 100644
--- a/src/ng/location.js
+++ b/src/ng/location.js
@@ -405,10 +405,13 @@ function locationGetterSetter(property, preprocess) {
  *
  * @requires $browser
  * @requires $sniffer
- * @requires $document
+ * @requires $rootElement
  *
  * @description
- * The $location service parses the URL in the browser address bar (based on the {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL available to your application. Changes to the URL in the address bar are reflected into $location service and changes to $location are reflected into the browser address bar.
+ * The $location service parses the URL in the browser address bar (based on the
+ * {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL
+ * available to your application. Changes to the URL in the address bar are reflected into
+ * $location service and changes to $location are reflected into the browser address bar.
  *
  * **The $location service:**
  *
@@ -421,7 +424,8 @@ function locationGetterSetter(property, preprocess) {
  *   - Clicks on a link.
  * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
  *
- * For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular Services: Using $location}
+ * For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular
+ * Services: Using $location}
  */
 
 /**
@@ -468,67 +472,75 @@ function $LocationProvider(){
     }
   };
 
-  this.$get = ['$rootScope', '$browser', '$sniffer', '$document',
-      function( $rootScope,   $browser,   $sniffer,   $document) {
-    var currentUrl,
+  this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement',
+      function( $rootScope,   $browser,   $sniffer,   $rootElement) {
+    var $location,
         basePath = $browser.baseHref() || '/',
         pathPrefix = pathPrefixFromBase(basePath),
-        initUrl = $browser.url();
+        initUrl = $browser.url(),
+        absUrlPrefix;
 
     if (html5Mode) {
       if ($sniffer.history) {
-        currentUrl = new LocationUrl(convertToHtml5Url(initUrl, basePath, hashPrefix), pathPrefix);
+        $location = new LocationUrl(
+          convertToHtml5Url(initUrl, basePath, hashPrefix),
+          pathPrefix);
       } else {
-        currentUrl = new LocationHashbangUrl(convertToHashbangUrl(initUrl, basePath, hashPrefix),
-                                             hashPrefix);
+        $location = new LocationHashbangUrl(
+          convertToHashbangUrl(initUrl, basePath, hashPrefix),
+          hashPrefix);
       }
+    } else {
+      $location = new LocationHashbangUrl(initUrl, hashPrefix);
+    }
 
-      // link rewriting
-      var u = currentUrl,
-          absUrlPrefix = composeProtocolHostPort(u.protocol(), u.host(), u.port()) + pathPrefix;
+    // link rewriting
+    absUrlPrefix = composeProtocolHostPort(
+        $location.protocol(), $location.host(), $location.port()) + pathPrefix;
 
-      $document.bind('click', function(event) {
-        // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
-        // currently we open nice url link and redirect then
+    $rootElement.bind('click', function(event) {
+      // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
+      // currently we open nice url link and redirect then
 
-        if (event.ctrlKey || event.metaKey || event.which == 2) return;
+      if (event.ctrlKey || event.metaKey || event.which == 2) return;
 
-        var elm = jqLite(event.target);
+      var elm = jqLite(event.target);
 
-        // traverse the DOM up to find first A tag
-        while (elm.length && lowercase(elm[0].nodeName) !== 'a') {
-          elm = elm.parent();
-        }
+      // traverse the DOM up to find first A tag
+      while (elm.length && lowercase(elm[0].nodeName) !== 'a') {
+        elm = elm.parent();
+      }
 
-        var absHref = elm.prop('href');
+      var absHref = elm.prop('href');
 
-        if (!absHref ||
-            elm.attr('target') ||
-            absHref.indexOf(absUrlPrefix) !== 0) { // link to different domain or base path
-          return;
-        }
+      if (!absHref ||
+        elm.attr('target') ||
+        absHref.indexOf(absUrlPrefix) !== 0) { // link to different domain or base path
+        return;
+      }
+
+      // update location with href without the prefix
+      $location.url(absHref.substr(absUrlPrefix.length));
+      $rootScope.$apply();
+      event.preventDefault();
+      // hack to work around FF6 bug 684208 when scenario runner clicks on links
+      window.angular['ff-684208-preventDefault'] = true;
+    });
 
-        // update location with href without the prefix
-        currentUrl.url(absHref.substr(absUrlPrefix.length));
-        $rootScope.$apply();
-        event.preventDefault();
-        // hack to work around FF6 bug 684208 when scenario runner clicks on links
-        window.angular['ff-684208-preventDefault'] = true;
-      });
-    } else {
-      currentUrl = new LocationHashbangUrl(initUrl, hashPrefix);
-    }
 
     // rewrite hashbang url <> html5 url
-    if (currentUrl.absUrl() != initUrl) {
-      $browser.url(currentUrl.absUrl(), true);
+    if ($location.absUrl() != initUrl) {
+      $browser.url($location.absUrl(), true);
     }
 
     // update $location when $browser url changes
     $browser.onUrlChange(function(newUrl) {
-      if (currentUrl.absUrl() != newUrl) {
+      if ($location.absUrl() != newUrl) {
         $rootScope.$evalAsync(function() {
-          currentUrl.$$parse(newUrl);
+          var oldUrl = $location.absUrl();
+
+          $location.$$parse(newUrl);
+          afterLocationChange(oldUrl);
         });
         if (!$rootScope.$$phase) $rootScope.$digest();
       }
@@ -537,17 +549,29 @@ function $LocationProvider(){
     // update browser
     var changeCounter = 0;
     $rootScope.$watch(function $locationWatch() {
-      if ($browser.url() != currentUrl.absUrl()) {
+      var oldUrl = $browser.url();
+
+      if (!changeCounter || oldUrl != $location.absUrl()) {
         changeCounter++;
         $rootScope.$evalAsync(function() {
-          $browser.url(currentUrl.absUrl(), currentUrl.$$replace);
-          currentUrl.$$replace = false;
+          if ($rootScope.$broadcast('$locationChangeStart', $location.absUrl(), oldUrl).
+              defaultPrevented) {
+            $location.$$parse(oldUrl);
+          } else {
+            $browser.url($location.absUrl(), $location.$$replace);
+            $location.$$replace = false;
+            afterLocationChange(oldUrl);
+          }
         });
       }
 
       return changeCounter;
     });
 
-    return currentUrl;
+    return $location;
+
+    function afterLocationChange(oldUrl) {
+      $rootScope.$broadcast('$locationChangeSuccess', $location.absUrl(), oldUrl);
+    }
 }];
 }
diff --git a/src/ng/rootElement.js b/src/ng/rootElement.js
index e69de29bb2d1..20e5bfc4a91d 100644
--- a/src/ng/rootElement.js
+++ b/src/ng/rootElement.js
@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * @ngdoc overview
+ * @name angular.module.ng.$rootElement
+ *
+ * @description
+ * The root element of Angular application. This is either the element where {@link
+ * angular.module.ng.$compileProvider.directive.ngApp ngApp} was declared or the element passed into
+ * {@link angular.bootstrap}. The element represent the root element of application. It is also the
+ * location where the applications {@link angular.module.AUTO.$injector $injector} service gets
+ * published, it can be retrieved using `$rootElement.injector()`.
+ */
+
+
+// the implementation is in angular.bootstrap
diff --git a/src/ng/route.js b/src/ng/route.js
index fd54b1c51ad1..ec05d1f8d6e4 100644
--- a/src/ng/route.js
+++ b/src/ng/route.js
@@ -19,7 +19,7 @@ function $RouteProvider(){
    * @methodOf angular.module.ng.$routeProvider
    *
    * @param {string} path Route path (matched against `$location.path`). If `$location.path`
-   *    contains redudant trailing slash or is missing one, the route will still match and the
+   *    contains redundant trailing slash or is missing one, the route will still match and the
    *    `$location.path` will be updated to add or drop the trailing slash to exacly match the
    *    route definition.
    * @param {Object} route Mapping information to be assigned to `$route.current` on route
@@ -29,16 +29,30 @@ function $RouteProvider(){
    *
    *    - `controller` – `{function()=}` – Controller fn that should be associated with newly
    *      created scope.
-   *    - `template` – `{string=}` – path to an html template that should be used by
+   *    - `template` – `{string=}` –  html template as a string that should be used by
    *      {@link angular.module.ng.$compileProvider.directive.ngView ngView} or
    *      {@link angular.module.ng.$compileProvider.directive.ngInclude ngInclude} directives.
+   *      this property takes precedence over `templateUrl`.
+   *    - `templateUrl` – `{string=}` – path to an html template that should be used by
+   *      {@link angular.module.ng.$compileProvider.directive.ngView ngView}.
+   *    - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
+   *      be injected into the controller. If any of these dependencies are promises, they will be
+   *      resolved and converted to a value before the controller is instantiated and the
+   *      `$aftreRouteChange` event is fired. The map object is:
+   *
+   *      - `key` – `{string}`: a name of a dependency to be injected into the controller.
+   *      - `factory` - `{string|function}`: If `string` then it is an alias for a service.
+   *        Otherwise if function, then it is {@link api/angular.module.AUTO.$injector#invoke injected}
+   *        and the return value is treated as the dependency. If the result is a promise, it is resolved
+   *        before its value is injected into the controller.
+   *
    *    - `redirectTo` – {(string|function())=} – value to update
    *      {@link angular.module.ng.$location $location} path with and trigger route redirection.
    *
    *      If `redirectTo` is a function, it will be called with the following parameters:
    *
    *      - `{Object.<string>}` - route parameters extracted from the current
-   *        `$location.path()` by applying the current route template.
+   *        `$location.path()` by applying the current route templateUrl.
    *      - `{string}` - current `$location.path()`
    *      - `{Object}` - current `$location.search()`
    *
@@ -89,8 +103,8 @@ function $RouteProvider(){
   };
 
 
-  this.$get = ['$rootScope', '$location', '$routeParams',
-      function( $rootScope,  $location,  $routeParams) {
+  this.$get = ['$rootScope', '$location', '$routeParams', '$q', '$injector', '$http', '$templateCache',
+      function( $rootScope,   $location,   $routeParams,   $q,   $injector,   $http,   $templateCache) {
 
     /**
      * @ngdoc object
@@ -99,6 +113,16 @@ function $RouteProvider(){
      * @requires $routeParams
      *
      * @property {Object} current Reference to the current route definition.
+     * The route definition contains:
+     *
+     *   - `controller`: The controller constructor as define in route definition.
+     *   - `locals`: A map of locals which is used by {@link angular.module.ng.$controller $controller} service for
+     *     controller instantiation. The `locals` contain
+     *     the resolved values of the `resolve` map. Additionally the `locals` also contain:
+     *
+     *     - `$scope` - The current route scope.
+     *     - `$template` - The current route template HTML.
+     *
      * @property {Array.<Object>} routes Array of all configured routes.
      *
      * @description
@@ -131,7 +155,7 @@ function $RouteProvider(){
            <hr />
 
            <pre>$location.path() = {{$location.path()}}</pre>
-           <pre>$route.current.template = {{$route.current.template}}</pre>
+           <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
            <pre>$route.current.params = {{$route.current.params}}</pre>
            <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
            <pre>$routeParams = {{$routeParams}}</pre>
@@ -152,11 +176,19 @@ function $RouteProvider(){
        <file name="script.js">
          angular.module('ngView', [], function($routeProvider, $locationProvider) {
            $routeProvider.when('/Book/:bookId', {
-             template: 'book.html',
-             controller: BookCntl
+             templateUrl: 'book.html',
+             controller: BookCntl,
+             resolve: {
+               // I will cause a 1 second delay
+               delay: function($q, $timeout) {
+                 var delay = $q.defer();
+                 $timeout(delay.resolve, 1000);
+                 return delay.promise;
+               }
+             }
            });
            $routeProvider.when('/Book/:bookId/ch/:chapterId', {
-             template: 'chapter.html',
+             templateUrl: 'chapter.html',
              controller: ChapterCntl
            });
 
@@ -190,6 +222,7 @@ function $RouteProvider(){
            expect(content).toMatch(/Chapter Id\: 1/);
 
            element('a:contains("Scarlet")').click();
+           sleep(2); // promises are not part of scenario waiting
            content = element('.doc-example-live [ng-view]').text();
            expect(content).toMatch(/controller\: BookCntl/);
            expect(content).toMatch(/Book Id\: Scarlet/);
@@ -200,11 +233,15 @@ function $RouteProvider(){
 
     /**
      * @ngdoc event
-     * @name angular.module.ng.$route#$beforeRouteChange
+     * @name angular.module.ng.$route#$routeChangeStart
      * @eventOf angular.module.ng.$route
      * @eventType broadcast on root scope
      * @description
-     * Broadcasted before a route change.
+     * Broadcasted before a route change. At this  point the route services starts
+     * resolving all of the dependencies needed for the route change to occurs.
+     * Typically this involves fetching the view template as well as any dependencies
+     * defined in `resolve` route property. Once  all of the dependencies are resolved
+     * `$routeChangeSuccess` is fired.
      *
      * @param {Route} next Future route information.
      * @param {Route} current Current route information.
@@ -212,16 +249,31 @@ function $RouteProvider(){
 
     /**
      * @ngdoc event
-     * @name angular.module.ng.$route#$afterRouteChange
+     * @name angular.module.ng.$route#$routeChangeSuccess
      * @eventOf angular.module.ng.$route
      * @eventType broadcast on root scope
      * @description
-     * Broadcasted after a route change.
+     * Broadcasted after a route dependencies are resolved.
+     * {@link angular.module.ng.$compileProvider.directive.ngView ngView} listens for the directive
+     * to instantiate the controller and render the view.
      *
      * @param {Route} current Current route information.
      * @param {Route} previous Previous route information.
      */
 
+    /**
+     * @ngdoc event
+     * @name angular.module.ng.$route#$routeChangeError
+     * @eventOf angular.module.ng.$route
+     * @eventType broadcast on root scope
+     * @description
+     * Broadcasted if any of the resolve promises are rejected.
+     *
+     * @param {Route} current Current route information.
+     * @param {Route} previous Previous route information.
+     * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise.
+     */
+
     /**
      * @ngdoc event
      * @name angular.module.ng.$route#$routeUpdate
@@ -234,7 +286,6 @@ function $RouteProvider(){
      */
 
     var matcher = switchRouteMatcher,
-        dirty = 0,
         forceReload = false,
         $route = {
           routes: routes,
@@ -245,19 +296,19 @@ function $RouteProvider(){
            * @methodOf angular.module.ng.$route
            *
            * @description
-           * Causes `$route` service to reload theR current route even if
+           * Causes `$route` service to reload the current route even if
            * {@link angular.module.ng.$location $location} hasn't changed.
            *
            * As a result of that, {@link angular.module.ng.$compileProvider.directive.ngView ngView}
            * creates new scope, reinstantiates the controller.
            */
           reload: function() {
-            dirty++;
             forceReload = true;
+            $rootScope.$evalAsync(updateRoute);
           }
         };
 
-    $rootScope.$watch(function() { return dirty + $location.url(); }, updateRoute);
+    $rootScope.$on('$locationChangeSuccess', updateRoute);
 
     return $route;
 
@@ -298,7 +349,7 @@ function $RouteProvider(){
         $rootScope.$broadcast('$routeUpdate', last);
       } else if (next || last) {
         forceReload = false;
-        $rootScope.$broadcast('$beforeRouteChange', next, last);
+        $rootScope.$broadcast('$routeChangeStart', next, last);
         $route.current = next;
         if (next) {
           if (next.redirectTo) {
@@ -309,11 +360,52 @@ function $RouteProvider(){
               $location.url(next.redirectTo(next.pathParams, $location.path(), $location.search()))
                        .replace();
             }
-          } else {
-            copy(next.params, $routeParams);
           }
         }
-        $rootScope.$broadcast('$afterRouteChange', next, last);
+
+        $q.when(next).
+          then(function() {
+            if (next) {
+              var keys = [],
+                  values = [],
+                  template;
+
+              forEach(next.resolve || {}, function(value, key) {
+                keys.push(key);
+                values.push(isFunction(value) ? $injector.invoke(value) : $injector.get(value));
+              });
+              if (isDefined(template = next.template)) {
+              } else if (isDefined(template = next.templateUrl)) {
+                template = $http.get(template, {cache: $templateCache}).
+                    then(function(response) { return response.data; });
+              }
+              if (isDefined(template)) {
+                keys.push('$template');
+                values.push(template);
+              }
+              return $q.all(values).then(function(values) {
+                var locals = {};
+                forEach(values, function(value, index) {
+                  locals[keys[index]] = value;
+                });
+                return locals;
+              });
+            }
+          }).
+          // after route change
+          then(function(locals) {
+            if (next == $route.current) {
+              if (next) {
+                next.locals = locals;
+                copy(next.params, $routeParams);
+              }
+              $rootScope.$broadcast('$routeChangeSuccess', next, last);
+            }
+          }, function(error) {
+            if (next == $route.current) {
+              $rootScope.$broadcast('$routeChangeError', next, last, error);
+            }
+          });
       }
     }
 
diff --git a/src/ngMock/angular-mocks.js b/src/ngMock/angular-mocks.js
index cf7707f24f58..bd7d2c400792 100644
--- a/src/ngMock/angular-mocks.js
+++ b/src/ngMock/angular-mocks.js
@@ -1347,6 +1347,15 @@ function MockXhr() {
  * Flushes the queue of pending tasks.
  */
 
+/**
+ *
+ */
+angular.mock.$RootElementProvider = function() {
+  this.$get = function() {
+    return angular.element('<div ng-app></div>');
+  }
+};
+
 /**
  * @ngdoc overview
  * @name angular.module.ngMock
@@ -1359,7 +1368,8 @@ angular.module('ngMock', ['ng']).provider({
   $browser: angular.mock.$BrowserProvider,
   $exceptionHandler: angular.mock.$ExceptionHandlerProvider,
   $log: angular.mock.$LogProvider,
-  $httpBackend: angular.mock.$HttpBackendProvider
+  $httpBackend: angular.mock.$HttpBackendProvider,
+  $rootElement: angular.mock.$RootElementProvider
 }).config(function($provide) {
   $provide.decorator('$timeout', function($delegate, $browser) {
     $delegate.flush = function() {
@@ -1370,7 +1380,6 @@ angular.module('ngMock', ['ng']).provider({
 });
 
 
-
 /**
  * @ngdoc overview
  * @name angular.module.ngMockE2E
diff --git a/test/auto/injectorSpec.js b/test/auto/injectorSpec.js
index 83bd3d1f81e2..33fecac616de 100644
--- a/test/auto/injectorSpec.js
+++ b/test/auto/injectorSpec.js
@@ -123,11 +123,11 @@ describe('injector', function() {
     it('should return $inject', function() {
       function fn() {}
       fn.$inject = ['a'];
-      expect(inferInjectionArgs(fn)).toBe(fn.$inject);
-      expect(inferInjectionArgs(function() {})).toEqual([]);
-      expect(inferInjectionArgs(function () {})).toEqual([]);
-      expect(inferInjectionArgs(function  () {})).toEqual([]);
-      expect(inferInjectionArgs(function /* */ () {})).toEqual([]);
+      expect(annotate(fn)).toBe(fn.$inject);
+      expect(annotate(function() {})).toEqual([]);
+      expect(annotate(function () {})).toEqual([]);
+      expect(annotate(function  () {})).toEqual([]);
+      expect(annotate(function /* */ () {})).toEqual([]);
     });
 
 
@@ -142,43 +142,48 @@ describe('injector', function() {
                  */
           _c,
           /* {some type} */ d) { extraParans();}
-      expect(inferInjectionArgs($f_n0)).toEqual(['$a', 'b_', '_c',  'd']);
+      expect(annotate($f_n0)).toEqual(['$a', 'b_', '_c',  'd']);
       expect($f_n0.$inject).toEqual(['$a', 'b_', '_c',  'd']);
     });
 
 
     it('should strip leading and trailing underscores from arg name during inference', function() {
       function beforeEachFn(_foo_) { /* foo = _foo_ */ };
-      expect(inferInjectionArgs(beforeEachFn)).toEqual(['foo']);
+      expect(annotate(beforeEachFn)).toEqual(['foo']);
     });
 
 
     it('should handle no arg functions', function() {
       function $f_n0() {}
-      expect(inferInjectionArgs($f_n0)).toEqual([]);
+      expect(annotate($f_n0)).toEqual([]);
       expect($f_n0.$inject).toEqual([]);
     });
 
 
     it('should handle no arg functions with spaces in the arguments list', function() {
       function fn( ) {}
-      expect(inferInjectionArgs(fn)).toEqual([]);
+      expect(annotate(fn)).toEqual([]);
       expect(fn.$inject).toEqual([]);
     });
 
 
     it('should handle args with both $ and _', function() {
       function $f_n0($a_) {}
-      expect(inferInjectionArgs($f_n0)).toEqual(['$a_']);
+      expect(annotate($f_n0)).toEqual(['$a_']);
       expect($f_n0.$inject).toEqual(['$a_']);
     });
 
 
     it('should throw on non function arg', function() {
       expect(function() {
-        inferInjectionArgs({});
+        annotate({});
       }).toThrow();
     });
+
+
+    it('should publish annotate API', function() {
+      expect(injector.annotate).toBe(annotate);
+    });
   });
 
 
diff --git a/test/ng/directive/ngViewSpec.js b/test/ng/directive/ngViewSpec.js
index 00fc68279009..e90bb3bd89e8 100644
--- a/test/ng/directive/ngViewSpec.js
+++ b/test/ng/directive/ngViewSpec.js
@@ -39,7 +39,7 @@ describe('ngView', function() {
         };
       });
 
-      $routeProvider.when('/some', {template: '/tpl.html', controller: Ctrl});
+      $routeProvider.when('/some', {templateUrl: '/tpl.html', controller: Ctrl});
     });
 
     inject(function($route, $rootScope, $templateCache, $location) {
@@ -59,7 +59,7 @@ describe('ngView', function() {
 
     module(function($controllerProvider, $routeProvider) {
       $controllerProvider.register('MyCtrl', ['$scope', MyCtrl]);
-      $routeProvider.when('/foo', {controller: 'MyCtrl', template: '/tpl.html'});
+      $routeProvider.when('/foo', {controller: 'MyCtrl', templateUrl: '/tpl.html'});
     });
 
     inject(function($route, $location, $rootScope, $templateCache) {
@@ -75,8 +75,8 @@ describe('ngView', function() {
 
   it('should load content via xhr when route changes', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'myUrl1'});
-      $routeProvider.when('/bar', {template: 'myUrl2'});
+      $routeProvider.when('/foo', {templateUrl: 'myUrl1'});
+      $routeProvider.when('/bar', {templateUrl: 'myUrl2'});
     });
 
     inject(function($rootScope, $compile, $httpBackend, $location, $route) {
@@ -97,9 +97,34 @@ describe('ngView', function() {
   });
 
 
+  it('should use inline content route changes', function() {
+    module(function($routeProvider) {
+      $routeProvider.when('/foo', {template: '<div>{{1+3}}</div>'});
+      $routeProvider.when('/bar', {template: 'angular is da best'});
+      $routeProvider.when('/blank', {template: ''});
+    });
+
+    inject(function($rootScope, $compile, $location, $route) {
+      expect(element.text()).toEqual('');
+
+      $location.path('/foo');
+      $rootScope.$digest();
+      expect(element.text()).toEqual('4');
+
+      $location.path('/bar');
+      $rootScope.$digest();
+      expect(element.text()).toEqual('angular is da best');
+
+      $location.path('/blank');
+      $rootScope.$digest();
+      expect(element.text()).toEqual('');
+    });
+  });
+
+
   it('should remove all content when location changes to an unknown route', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'myUrl1'});
+      $routeProvider.when('/foo', {templateUrl: 'myUrl1'});
     });
 
     inject(function($rootScope, $compile, $location, $httpBackend, $route) {
@@ -118,7 +143,7 @@ describe('ngView', function() {
 
   it('should chain scopes and propagate evals to the child scope', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'myUrl1'});
+      $routeProvider.when('/foo', {templateUrl: 'myUrl1'});
     });
 
     inject(function($rootScope, $compile, $location, $httpBackend, $route) {
@@ -140,7 +165,7 @@ describe('ngView', function() {
   it('should be possible to nest ngView in ngInclude', function() {
 
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'viewPartial.html'});
+      $routeProvider.when('/foo', {templateUrl: 'viewPartial.html'});
     });
 
     inject(function($httpBackend, $location, $route, $compile, $rootScope) {
@@ -156,7 +181,7 @@ describe('ngView', function() {
       $httpBackend.flush();
 
       expect(elm.text()).toEqual('include: view: content');
-      expect($route.current.template).toEqual('viewPartial.html');
+      expect($route.current.templateUrl).toEqual('viewPartial.html');
       dealoc(elm)
     });
   });
@@ -170,7 +195,7 @@ describe('ngView', function() {
     }
 
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {controller: ParentCtrl, template: 'viewPartial.html'});
+      $routeProvider.when('/foo', {controller: ParentCtrl, templateUrl: 'viewPartial.html'});
     });
 
 
@@ -209,8 +234,8 @@ describe('ngView', function() {
     // this is a test for a bad race condition that affected feedback
 
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'myUrl1'});
-      $routeProvider.when('/bar', {template: 'myUrl2'});
+      $routeProvider.when('/foo', {templateUrl: 'myUrl1'});
+      $routeProvider.when('/bar', {templateUrl: 'myUrl2'});
     });
 
     inject(function($route, $rootScope, $location, $httpBackend) {
@@ -229,27 +254,9 @@ describe('ngView', function() {
   });
 
 
-  it('should clear the content when error during xhr request', function() {
-    module(function($routeProvider) {
-      $routeProvider.when('/foo', {controller: noop, template: 'myUrl1'});
-    });
-
-    inject(function($route, $location, $rootScope, $httpBackend) {
-      $location.path('/foo');
-      $httpBackend.expect('GET', 'myUrl1').respond(404, '');
-      element.text('content');
-
-      $rootScope.$digest();
-      $httpBackend.flush();
-
-      expect(element.text()).toBe('');
-    });
-  });
-
-
   it('should be async even if served from cache', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {controller: noop, template: 'myUrl1'});
+      $routeProvider.when('/foo', {controller: noop, templateUrl: 'myUrl1'});
     });
 
     inject(function($route, $rootScope, $location, $templateCache) {
@@ -280,12 +287,12 @@ describe('ngView', function() {
     };
 
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'tpl.html', controller: Ctrl});
+      $routeProvider.when('/foo', {templateUrl: 'tpl.html', controller: Ctrl});
     });
 
     inject(function($templateCache, $rootScope, $location) {
-      $rootScope.$on('$beforeRouteChange', logger('$beforeRouteChange'));
-      $rootScope.$on('$afterRouteChange', logger('$afterRouteChange'));
+      $rootScope.$on('$routeChangeStart', logger('$routeChangeStart'));
+      $rootScope.$on('$routeChangeSuccess', logger('$routeChangeSuccess'));
       $rootScope.$on('$viewContentLoaded', logger('$viewContentLoaded'));
 
       $templateCache.put('tpl.html', [200, '{{value}}', {}]);
@@ -293,14 +300,14 @@ describe('ngView', function() {
       $rootScope.$digest();
 
       expect(element.text()).toBe('bound-value');
-      expect(log).toEqual(['$beforeRouteChange', '$afterRouteChange', 'init-ctrl',
-                           '$viewContentLoaded']);
+      expect(log).toEqual([
+        '$routeChangeStart', 'init-ctrl', '$viewContentLoaded', '$routeChangeSuccess' ]);
     });
   });
 
   it('should destroy previous scope', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'tpl.html'});
+      $routeProvider.when('/foo', {templateUrl: 'tpl.html'});
     });
 
     inject(function($templateCache, $rootScope, $location) {
@@ -337,8 +344,8 @@ describe('ngView', function() {
     };
 
     module(function($routeProvider) {
-      $routeProvider.when('/one', {template: 'one.html', controller: createCtrl('ctrl1')});
-      $routeProvider.when('/two', {template: 'two.html', controller: createCtrl('ctrl2')});
+      $routeProvider.when('/one', {templateUrl: 'one.html', controller: createCtrl('ctrl1')});
+      $routeProvider.when('/two', {templateUrl: 'two.html', controller: createCtrl('ctrl2')});
     });
 
     inject(function($httpBackend, $rootScope, $location) {
@@ -386,9 +393,9 @@ describe('ngView', function() {
     }
 
     module(function($routeProvider) {
-      $routeProvider.when('/bar', {template: 'tpl.html', controller: createController('bar')});
+      $routeProvider.when('/bar', {templateUrl: 'tpl.html', controller: createController('bar')});
       $routeProvider.when('/foo', {
-          template: 'tpl.html', controller: createController('foo'), reloadOnSearch: false});
+          templateUrl: 'tpl.html', controller: createController('foo'), reloadOnSearch: false});
     });
 
     inject(function($templateCache, $location, $rootScope) {
@@ -411,7 +418,7 @@ describe('ngView', function() {
 
   it('should evaluate onload expression after linking the content', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'tpl.html'});
+      $routeProvider.when('/foo', {templateUrl: 'tpl.html'});
     });
 
     inject(function($templateCache, $location, $rootScope) {
@@ -432,7 +439,7 @@ describe('ngView', function() {
     }
 
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'tpl.html', controller: MyCtrl});
+      $routeProvider.when('/foo', {templateUrl: 'tpl.html', controller: MyCtrl});
     });
 
     inject(function($templateCache, $location, $rootScope, $route) {
diff --git a/test/ng/locationSpec.js b/test/ng/locationSpec.js
index b866b1e3da7d..8b876a3ca0cd 100644
--- a/test/ng/locationSpec.js
+++ b/test/ng/locationSpec.js
@@ -498,8 +498,8 @@ describe('$location', function() {
   // html5 history enabled, but not supported by browser
   describe('history on old browser', function() {
 
-    afterEach(inject(function($document){
-      dealoc($document);
+    afterEach(inject(function($rootElement){
+      dealoc($rootElement);
     }));
 
     it('should use hashbang url with hash prefix', function() {
@@ -532,8 +532,8 @@ describe('$location', function() {
   // html5 history enabled and supported by browser
   describe('history on new browser', function() {
 
-    afterEach(inject(function($document){
-      dealoc($document);
+    afterEach(inject(function($rootElement){
+      dealoc($rootElement);
     }));
 
     it('should use new url', function() {
@@ -681,7 +681,6 @@ describe('$location', function() {
 
     function configureService(linkHref, html5Mode, supportHist, attrs, content) {
       module(function($provide, $locationProvider) {
-        var jqRoot = jqLite('<div></div>');
         attrs = attrs ? ' ' + attrs + ' ' : '';
 
         // fake the base behavior
@@ -692,14 +691,16 @@ describe('$location', function() {
         }
 
         link = jqLite('<a href="' + linkHref + '"' + attrs + '>' + content + '</a>')[0];
-        root = jqRoot.append(link)[0];
 
-        jqLite(document.body).append(jqRoot);
-
-        $provide.value('$document', jqRoot);
         $provide.value('$sniffer', {history: supportHist});
         $locationProvider.html5Mode(html5Mode);
         $locationProvider.hashPrefix('!');
+        return function($rootElement, $document) {
+          $rootElement.append(link);
+          root = $rootElement[0];
+          // we need to do this otherwise we can't simulate events
+          $document.find('body').append($rootElement);
+        };
       });
     }
 
@@ -711,11 +712,11 @@ describe('$location', function() {
     }
 
     function initLocation() {
-      return function($browser, $location, $document) {
+      return function($browser, $location, $rootElement) {
         originalBrowser = $browser.url();
         // we have to prevent the default operation, as we need to test absolute links (http://...)
         // and navigating to these links would kill jstd
-        $document.bind('click', function(e) {
+        $rootElement.bind('click', function(e) {
           lastEventPreventDefault = e.isDefaultPrevented();
           e.preventDefault();
         });
@@ -790,19 +791,6 @@ describe('$location', function() {
     });
 
 
-    it('should not rewrite when history disabled', function() {
-      configureService('#new', false);
-      inject(
-        initBrowser(),
-        initLocation(),
-        function($browser) {
-          browserTrigger(link, 'click');
-          expectNoRewrite($browser);
-        }
-      );
-    });
-
-
     it('should not rewrite full url links do different domain', function() {
       configureService('http://www.dot.abc/a?b=c', true);
       inject(
@@ -981,4 +969,148 @@ describe('$location', function() {
       });
     }
   });
+
+
+  describe('location cancellation', function() {
+    it('should fire $before/afterLocationChange event', inject(function($location, $browser, $rootScope, $log) {
+      expect($browser.url()).toEqual('http://server/');
+
+      $rootScope.$on('$locationChangeStart', function(event, newUrl, oldUrl) {
+        $log.info('before', newUrl, oldUrl, $browser.url());
+      });
+      $rootScope.$on('$locationChangeSuccess', function(event, newUrl, oldUrl) {
+        $log.info('after', newUrl, oldUrl, $browser.url());
+      });
+
+      expect($location.url()).toEqual('');
+      $location.url('/somePath');
+      expect($location.url()).toEqual('/somePath');
+      expect($browser.url()).toEqual('http://server/');
+      expect($log.info.logs).toEqual([]);
+
+      $rootScope.$apply();
+
+      expect($log.info.logs.shift()).
+          toEqual(['before', 'http://server/#/somePath', 'http://server/', 'http://server/']);
+      expect($log.info.logs.shift()).
+          toEqual(['after', 'http://server/#/somePath', 'http://server/', 'http://server/#/somePath']);
+      expect($location.url()).toEqual('/somePath');
+      expect($browser.url()).toEqual('http://server/#/somePath');
+    }));
+
+
+    it('should allow $locationChangeStart event cancellation', inject(function($location, $browser, $rootScope, $log) {
+      expect($browser.url()).toEqual('http://server/');
+      expect($location.url()).toEqual('');
+
+      $rootScope.$on('$locationChangeStart', function(event, newUrl, oldUrl) {
+        $log.info('before', newUrl, oldUrl, $browser.url());
+        event.preventDefault();
+      });
+      $rootScope.$on('$locationChangeCompleted', function(event, newUrl, oldUrl) {
+        throw Error('location should have been canceled');
+      });
+
+      expect($location.url()).toEqual('');
+      $location.url('/somePath');
+      expect($location.url()).toEqual('/somePath');
+      expect($browser.url()).toEqual('http://server/');
+      expect($log.info.logs).toEqual([]);
+
+      $rootScope.$apply();
+
+      expect($log.info.logs.shift()).
+          toEqual(['before', 'http://server/#/somePath', 'http://server/', 'http://server/']);
+      expect($log.info.logs[1]).toBeUndefined();
+      expect($location.url()).toEqual('');
+      expect($browser.url()).toEqual('http://server/');
+    }));
+
+    it ('should fire $locationChangeCompleted event when change from browser location bar',
+      inject(function($log, $location, $browser, $rootScope) {
+        $rootScope.$apply(); // clear initial $locationChangeStart
+
+        expect($browser.url()).toEqual('http://server/');
+        expect($location.url()).toEqual('');
+
+        $rootScope.$on('$locationChangeStart', function(event, newUrl, oldUrl) {
+          throw Error('there is no before when user enters URL directly to browser');
+        });
+        $rootScope.$on('$locationChangeSuccess', function(event, newUrl, oldUrl) {
+          $log.info('after', newUrl, oldUrl);
+        });
+
+
+        $browser.url('http://server/#/somePath');
+        $browser.poll();
+
+        expect($log.info.logs.shift()).
+          toEqual(['after', 'http://server/#/somePath', 'http://server/']);
+      })
+    );
+
+
+    it('should listen on click events on href and prevent browser default in hasbang mode', function() {
+      module(function() {
+        return function($rootElement, $compile, $rootScope) {
+          $rootElement.html('<a href="http://server/#/somePath">link</a>');
+          $compile($rootElement)($rootScope);
+          jqLite(document.body).append($rootElement);
+        }
+      });
+
+      inject(function($location, $rootScope, $browser, $rootElement) {
+        var log = '',
+            link = $rootElement.find('a');
+
+
+        $rootScope.$on('$locationChangeStart', function(event) {
+          event.preventDefault();
+          log += '$locationChangeStart';
+        });
+        $rootScope.$on('$locationChangeCompleted', function() {
+          throw new Error('after cancellation in hashbang mode');
+        });
+
+        browserTrigger(link, 'click');
+
+        expect(log).toEqual('$locationChangeStart');
+        expect($browser.url()).toEqual('http://server/');
+
+        dealoc($rootElement);
+      });
+    });
+
+
+    it('should listen on click events on href and prevent browser default in html5 mode', function() {
+      module(function($locationProvider) {
+        $locationProvider.html5Mode(true);
+        return function($rootElement, $compile, $rootScope) {
+          $rootElement.html('<a href="http://server/somePath">link</a>');
+          $compile($rootElement)($rootScope);
+          jqLite(document.body).append($rootElement);
+        }
+      });
+
+      inject(function($location, $rootScope, $browser, $rootElement) {
+        var log = '',
+          link = $rootElement.find('a');
+
+        $rootScope.$on('$locationChangeStart', function(event) {
+          event.preventDefault();
+          log += '$locationChangeStart';
+        });
+        $rootScope.$on('$locationChangeCompleted', function() {
+          throw new Error('after cancalation in html5 mode');
+        });
+
+        browserTrigger(link, 'click');
+
+        expect(log).toEqual('$locationChangeStart');
+        expect($browser.url()).toEqual('http://server/');
+
+        dealoc($rootElement);
+      });
+    });
+  });
 });
diff --git a/test/ng/rootElementSpec.js b/test/ng/rootElementSpec.js
new file mode 100644
index 000000000000..812720938598
--- /dev/null
+++ b/test/ng/rootElementSpec.js
@@ -0,0 +1,12 @@
+'use strict';
+
+describe('$rootElement', function() {
+  it('should publish the bootstrap element into $rootElement', function() {
+    var element = jqLite('<div></div>');
+    var injector = angular.bootstrap(element);
+
+    expect(injector.get('$rootElement')[0]).toBe(element[0]);
+
+    dealoc(element);
+  });
+});
diff --git a/test/ng/routeSpec.js b/test/ng/routeSpec.js
index b66cbb8edeec..31d932f72366 100644
--- a/test/ng/routeSpec.js
+++ b/test/ng/routeSpec.js
@@ -1,6 +1,19 @@
 'use strict';
 
 describe('$route', function() {
+  var $httpBackend;
+
+  beforeEach(module(function() {
+    return function(_$httpBackend_) {
+      $httpBackend = _$httpBackend_;
+      $httpBackend.when('GET', 'Chapter.html').respond('chapter');
+      $httpBackend.when('GET', 'test.html').respond('test');
+      $httpBackend.when('GET', 'foo.html').respond('foo');
+      $httpBackend.when('GET', 'baz.html').respond('baz');
+      $httpBackend.when('GET', 'bar.html').respond('bar');
+      $httpBackend.when('GET', '404.html').respond('not found');
+    };
+  }));
 
   it('should route and fire change event', function() {
     var log = '',
@@ -9,17 +22,17 @@ describe('$route', function() {
 
     module(function($routeProvider) {
       $routeProvider.when('/Book/:book/Chapter/:chapter',
-          {controller: noop, template: 'Chapter.html'});
+          {controller: noop, templateUrl: 'Chapter.html'});
       $routeProvider.when('/Blank', {});
     });
     inject(function($route, $location, $rootScope) {
-      $rootScope.$on('$beforeRouteChange', function(event, next, current) {
+      $rootScope.$on('$routeChangeStart', function(event, next, current) {
         log += 'before();';
         expect(current).toBe($route.current);
         lastRoute = current;
         nextRoute = next;
       });
-      $rootScope.$on('$afterRouteChange', function(event, current, last) {
+      $rootScope.$on('$routeChangeSuccess', function(event, current, last) {
         log += 'after();';
         expect(current).toBe($route.current);
         expect(lastRoute).toBe(last);
@@ -28,6 +41,7 @@ describe('$route', function() {
 
       $location.path('/Book/Moby/Chapter/Intro').search('p=123');
       $rootScope.$digest();
+      $httpBackend.flush();
       expect(log).toEqual('before();after();');
       expect($route.current.params).toEqual({book:'Moby', chapter:'Intro', p:'123'});
 
@@ -46,9 +60,31 @@ describe('$route', function() {
   });
 
 
+  it('should not change route when location is canceled', function() {
+    module(function($routeProvider) {
+      $routeProvider.when('/somePath', {template: 'some path'});
+    });
+    inject(function($route, $location, $rootScope, $log) {
+      $rootScope.$on('$locationChangeStart', function(event) {
+        $log.info('$locationChangeStart');
+        event.preventDefault();
+      });
+
+      $rootScope.$on('$beforeRouteChange', function(event) {
+        throw new Error('Should not get here');
+      });
+
+      $location.path('/somePath');
+      $rootScope.$digest();
+
+      expect($log.info.logs.shift()).toEqual(['$locationChangeStart']);
+    });
+  });
+
+
   it('should match a route that contains special chars in the path', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/$test.23/foo(bar)/:baz', {template: 'test.html'});
+      $routeProvider.when('/$test.23/foo(bar)/:baz', {templateUrl: 'test.html'});
     });
     inject(function($route, $location, $rootScope) {
 
@@ -73,13 +109,13 @@ describe('$route', function() {
 
   it('should change route even when only search param changes', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/test', {template: 'test.html'});
+      $routeProvider.when('/test', {templateUrl: 'test.html'});
     });
 
     inject(function($route, $location, $rootScope) {
       var callback = jasmine.createSpy('onRouteChange');
 
-      $rootScope.$on('$beforeRouteChange', callback);
+      $rootScope.$on('$routeChangeStart', callback);
       $location.path('/test');
       $rootScope.$digest();
       callback.reset();
@@ -94,20 +130,20 @@ describe('$route', function() {
 
   it('should allow routes to be defined with just templates without controllers', function() {
     module(function($routeProvider) {
-      $routeProvider.when('/foo', {template: 'foo.html'});
+      $routeProvider.when('/foo', {templateUrl: 'foo.html'});
     });
 
     inject(function($route, $location, $rootScope) {
       var onChangeSpy = jasmine.createSpy('onChange');
 
-      $rootScope.$on('$beforeRouteChange', onChangeSpy);
+      $rootScope.$on('$routeChangeStart', onChangeSpy);
       expect($route.current).toBeUndefined();
       expect(onChangeSpy).not.toHaveBeenCalled();
 
       $location.path('/foo');
       $rootScope.$digest();
 
-      expect($route.current.template).toEqual('foo.html');
+      expect($route.current.templateUrl).toEqual('foo.html');
       expect($route.current.controller).toBeUndefined();
       expect(onChangeSpy).toHaveBeenCalled();
     });
@@ -118,21 +154,21 @@ describe('$route', function() {
     function NotFoundCtrl() {}
 
     module(function($routeProvider){
-      $routeProvider.when('/foo', {template: 'foo.html'});
-      $routeProvider.otherwise({template: '404.html', controller: NotFoundCtrl});
+      $routeProvider.when('/foo', {templateUrl: 'foo.html'});
+      $routeProvider.otherwise({templateUrl: '404.html', controller: NotFoundCtrl});
     });
 
     inject(function($route, $location, $rootScope) {
       var onChangeSpy = jasmine.createSpy('onChange');
 
-      $rootScope.$on('$beforeRouteChange', onChangeSpy);
+      $rootScope.$on('$routeChangeStart', onChangeSpy);
       expect($route.current).toBeUndefined();
       expect(onChangeSpy).not.toHaveBeenCalled();
 
       $location.path('/unknownRoute');
       $rootScope.$digest();
 
-      expect($route.current.template).toBe('404.html');
+      expect($route.current.templateUrl).toBe('404.html');
       expect($route.current.controller).toBe(NotFoundCtrl);
       expect(onChangeSpy).toHaveBeenCalled();
 
@@ -140,7 +176,7 @@ describe('$route', function() {
       $location.path('/foo');
       $rootScope.$digest();
 
-      expect($route.current.template).toEqual('foo.html');
+      expect($route.current.templateUrl).toEqual('foo.html');
       expect($route.current.controller).toBeUndefined();
       expect(onChangeSpy).toHaveBeenCalled();
     });
@@ -149,69 +185,283 @@ describe('$route', function() {
 
   it('should chain whens and otherwise', function() {
     module(function($routeProvider){
-      $routeProvider.when('/foo', {template: 'foo.html'}).
-                     otherwise({template: 'bar.html'}).
-                     when('/baz', {template: 'baz.html'});
+      $routeProvider.when('/foo', {templateUrl: 'foo.html'}).
+                     otherwise({templateUrl: 'bar.html'}).
+                     when('/baz', {templateUrl: 'baz.html'});
     });
 
     inject(function($route, $location, $rootScope) {
       $rootScope.$digest();
-      expect($route.current.template).toBe('bar.html');
+      expect($route.current.templateUrl).toBe('bar.html');
 
       $location.url('/baz');
       $rootScope.$digest();
-      expect($route.current.template).toBe('baz.html');
+      expect($route.current.templateUrl).toBe('baz.html');
     });
   });
 
 
-  it('should not fire $after/beforeRouteChange during bootstrap (if no route)', function() {
-    var routeChangeSpy = jasmine.createSpy('route change');
+  describe('events', function() {
+    it('should not fire $after/beforeRouteChange during bootstrap (if no route)', function() {
+      var routeChangeSpy = jasmine.createSpy('route change');
 
-    module(function($routeProvider) {
-      $routeProvider.when('/one', {}); // no otherwise defined
+      module(function($routeProvider) {
+        $routeProvider.when('/one', {}); // no otherwise defined
+      });
+
+      inject(function($rootScope, $route, $location) {
+        $rootScope.$on('$routeChangeStart', routeChangeSpy);
+        $rootScope.$on('$routeChangeSuccess', routeChangeSpy);
+
+        $rootScope.$digest();
+        expect(routeChangeSpy).not.toHaveBeenCalled();
+
+        $location.path('/no-route-here');
+        $rootScope.$digest();
+        expect(routeChangeSpy).not.toHaveBeenCalled();
+      });
     });
 
-    inject(function($rootScope, $route, $location) {
-      $rootScope.$on('$beforeRouteChange', routeChangeSpy);
-      $rootScope.$on('$afterRouteChange', routeChangeSpy);
+    it('should fire $routeChangeStart and resolve promises', function() {
+      var deferA,
+          deferB;
 
-      $rootScope.$digest();
-      expect(routeChangeSpy).not.toHaveBeenCalled();
+      module(function($provide, $routeProvider) {
+        $provide.factory('b', function($q) {
+          deferB = $q.defer();
+          return deferB.promise;
+        });
+        $routeProvider.when('/path', { templateUrl: 'foo.html', resolve: {
+          a: function($q) {
+            deferA = $q.defer();
+            return deferA.promise;
+          },
+          b: 'b'
+        } });
+      });
 
-      $location.path('/no-route-here');
-      $rootScope.$digest();
-      expect(routeChangeSpy).not.toHaveBeenCalled();
+      inject(function($location, $route, $rootScope, $httpBackend) {
+        var log = '';
+
+        $httpBackend.expectGET('foo.html').respond('FOO');
+
+        $location.path('/path');
+        $rootScope.$digest();
+        expect(log).toEqual('');
+        $httpBackend.flush();
+        expect(log).toEqual('');
+        deferA.resolve();
+        $rootScope.$digest();
+        expect(log).toEqual('');
+        deferB.resolve();
+        $rootScope.$digest();
+        expect($route.current.locals.$template).toEqual('FOO');
+      });
     });
-  });
 
 
+    it('should fire $routeChangeError event on resolution error', function() {
+      var deferA;
+
+      module(function($provide, $routeProvider) {
+        $routeProvider.when('/path', { template: 'foo', resolve: {
+          a: function($q) {
+            deferA = $q.defer();
+            return deferA.promise;
+          }
+        } });
+      });
+
+      inject(function($location, $route, $rootScope) {
+        var log = '';
+
+        $rootScope.$on('$routeChangeStart', function() { log += 'before();'; });
+        $rootScope.$on('$routeChangeError', function(e, n, l, reason) { log += 'failed(' + reason + ');'; });
+
+        $location.path('/path');
+        $rootScope.$digest();
+        expect(log).toEqual('before();');
+
+        deferA.reject('MyError');
+        $rootScope.$digest();
+        expect(log).toEqual('before();failed(MyError);');
+      });
+    });
+
+
+    it('should fetch templates', function() {
+      module(function($routeProvider) {
+        $routeProvider.
+          when('/r1', { templateUrl: 'r1.html' }).
+          when('/r2', { templateUrl: 'r2.html' });
+      });
+
+      inject(function($route, $httpBackend, $location, $rootScope) {
+        var log = '';
+        $rootScope.$on('$routeChangeStart', function(e, next) { log += '$before(' + next.templateUrl + ');'});
+        $rootScope.$on('$routeChangeSuccess', function(e, next) { log += '$after(' + next.templateUrl + ');'});
+
+        $httpBackend.expectGET('r1.html').respond('R1');
+        $httpBackend.expectGET('r2.html').respond('R2');
+
+        $location.path('/r1');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);');
+
+        $location.path('/r2');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);$before(r2.html);');
+
+        $httpBackend.flush();
+        expect(log).toBe('$before(r1.html);$before(r2.html);$after(r2.html);');
+        expect(log).not.toContain('$after(r1.html);');
+      });
+    });
+
+
+    it('should not update $routeParams until $routeChangeSuccess', function() {
+      module(function($routeProvider) {
+        $routeProvider.
+          when('/r1/:id', { templateUrl: 'r1.html' }).
+          when('/r2/:id', { templateUrl: 'r2.html' });
+      });
+
+      inject(function($route, $httpBackend, $location, $rootScope, $routeParams) {
+        var log = '';
+        $rootScope.$on('$routeChangeStart', function(e, next) { log += '$before' + toJson($routeParams) + ';'});
+        $rootScope.$on('$routeChangeSuccess', function(e, next) { log += '$after' + toJson($routeParams) + ';'});
+
+        $httpBackend.whenGET('r1.html').respond('R1');
+        $httpBackend.whenGET('r2.html').respond('R2');
+
+        $location.path('/r1/1');
+        $rootScope.$digest();
+        expect(log).toBe('$before{};');
+        $httpBackend.flush();
+        expect(log).toBe('$before{};$after{"id":"1"};');
+
+        log = '';
+
+        $location.path('/r2/2');
+        $rootScope.$digest();
+        expect(log).toBe('$before{"id":"1"};');
+        $httpBackend.flush();
+        expect(log).toBe('$before{"id":"1"};$after{"id":"2"};');
+      });
+    });
+
+
+    it('should drop in progress route change when new route change occurs', function() {
+      module(function($routeProvider) {
+        $routeProvider.
+          when('/r1', { templateUrl: 'r1.html' }).
+          when('/r2', { templateUrl: 'r2.html' });
+      });
+
+      inject(function($route, $httpBackend, $location, $rootScope) {
+        var log = '';
+        $rootScope.$on('$routeChangeStart', function(e, next) { log += '$before(' + next.templateUrl + ');'});
+        $rootScope.$on('$routeChangeSuccess', function(e, next) { log += '$after(' + next.templateUrl + ');'});
+
+        $httpBackend.expectGET('r1.html').respond('R1');
+        $httpBackend.expectGET('r2.html').respond('R2');
+
+        $location.path('/r1');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);');
+
+        $location.path('/r2');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);$before(r2.html);');
+
+        $httpBackend.flush();
+        expect(log).toBe('$before(r1.html);$before(r2.html);$after(r2.html);');
+        expect(log).not.toContain('$after(r1.html);');
+      });
+    });
+
+
+    it('should drop in progress route change when new route change occurs and old fails', function() {
+      module(function($routeProvider) {
+        $routeProvider.
+          when('/r1', { templateUrl: 'r1.html' }).
+          when('/r2', { templateUrl: 'r2.html' });
+      });
+
+      inject(function($route, $httpBackend, $location, $rootScope) {
+        var log = '';
+        $rootScope.$on('$routeChangeError', function(e, next, last, error) {
+          log += '$failed(' + next.templateUrl + ', ' + error.status + ');';
+        });
+        $rootScope.$on('$routeChangeStart', function(e, next) { log += '$before(' + next.templateUrl + ');'});
+        $rootScope.$on('$routeChangeSuccess', function(e, next) { log += '$after(' + next.templateUrl + ');'});
+
+        $httpBackend.expectGET('r1.html').respond(404, 'R1');
+        $httpBackend.expectGET('r2.html').respond('R2');
+
+        $location.path('/r1');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);');
+
+        $location.path('/r2');
+        $rootScope.$digest();
+        expect(log).toBe('$before(r1.html);$before(r2.html);');
+
+        $httpBackend.flush();
+        expect(log).toBe('$before(r1.html);$before(r2.html);$after(r2.html);');
+        expect(log).not.toContain('$after(r1.html);');
+      });
+    });
+
+
+    it('should catch local factory errors', function() {
+      var myError = new Error('MyError');
+      module(function($routeProvider, $exceptionHandlerProvider) {
+        $exceptionHandlerProvider.mode('log');
+        $routeProvider.when('/locals', {
+          resolve: {
+            a: function($q) {
+              throw myError;
+            }
+          }
+        });
+      });
+
+      inject(function($location, $route, $rootScope, $exceptionHandler) {
+        $location.path('/locals');
+        $rootScope.$digest();
+        expect($exceptionHandler.errors).toEqual([myError]);
+      });
+    });
+  });
+  
+  
   it('should match route with and without trailing slash', function() {
     module(function($routeProvider){
-      $routeProvider.when('/foo', {template: 'foo.html'});
-      $routeProvider.when('/bar/', {template: 'bar.html'});
+      $routeProvider.when('/foo', {templateUrl: 'foo.html'});
+      $routeProvider.when('/bar/', {templateUrl: 'bar.html'});
     });
 
     inject(function($route, $location, $rootScope) {
       $location.path('/foo');
       $rootScope.$digest();
       expect($location.path()).toBe('/foo');
-      expect($route.current.template).toBe('foo.html');
+      expect($route.current.templateUrl).toBe('foo.html');
 
       $location.path('/foo/');
       $rootScope.$digest();
       expect($location.path()).toBe('/foo');
-      expect($route.current.template).toBe('foo.html');
+      expect($route.current.templateUrl).toBe('foo.html');
 
       $location.path('/bar');
       $rootScope.$digest();
       expect($location.path()).toBe('/bar/');
-      expect($route.current.template).toBe('bar.html');
+      expect($route.current.templateUrl).toBe('bar.html');
 
       $location.path('/bar/');
       $rootScope.$digest();
       expect($location.path()).toBe('/bar/');
-      expect($route.current.template).toBe('bar.html');
+      expect($route.current.templateUrl).toBe('bar.html');
     });
   });
 
@@ -220,30 +470,30 @@ describe('$route', function() {
     it('should support redirection via redirectTo property by updating $location', function() {
       module(function($routeProvider) {
         $routeProvider.when('/', {redirectTo: '/foo'});
-        $routeProvider.when('/foo', {template: 'foo.html'});
-        $routeProvider.when('/bar', {template: 'bar.html'});
+        $routeProvider.when('/foo', {templateUrl: 'foo.html'});
+        $routeProvider.when('/bar', {templateUrl: 'bar.html'});
         $routeProvider.when('/baz', {redirectTo: '/bar'});
-        $routeProvider.otherwise({template: '404.html'});
+        $routeProvider.otherwise({templateUrl: '404.html'});
       });
 
       inject(function($route, $location, $rootScope) {
         var onChangeSpy = jasmine.createSpy('onChange');
 
-        $rootScope.$on('$beforeRouteChange', onChangeSpy);
+        $rootScope.$on('$routeChangeStart', onChangeSpy);
         expect($route.current).toBeUndefined();
         expect(onChangeSpy).not.toHaveBeenCalled();
 
         $location.path('/');
         $rootScope.$digest();
         expect($location.path()).toBe('/foo');
-        expect($route.current.template).toBe('foo.html');
+        expect($route.current.templateUrl).toBe('foo.html');
         expect(onChangeSpy.callCount).toBe(2);
 
         onChangeSpy.reset();
         $location.path('/baz');
         $rootScope.$digest();
         expect($location.path()).toBe('/bar');
-        expect($route.current.template).toBe('bar.html');
+        expect($route.current.templateUrl).toBe('bar.html');
         expect(onChangeSpy.callCount).toBe(2);
       });
     });
@@ -252,7 +502,7 @@ describe('$route', function() {
     it('should interpolate route vars in the redirected path from original path', function() {
       module(function($routeProvider) {
         $routeProvider.when('/foo/:id/foo/:subid/:extraId', {redirectTo: '/bar/:id/:subid/23'});
-        $routeProvider.when('/bar/:id/:subid/:subsubid', {template: 'bar.html'});
+        $routeProvider.when('/bar/:id/:subid/:subsubid', {templateUrl: 'bar.html'});
       });
 
       inject(function($route, $location, $rootScope) {
@@ -261,14 +511,14 @@ describe('$route', function() {
 
         expect($location.path()).toEqual('/bar/id1/subid3/23');
         expect($location.search()).toEqual({extraId: 'gah'});
-        expect($route.current.template).toEqual('bar.html');
+        expect($route.current.templateUrl).toEqual('bar.html');
       });
     });
 
 
     it('should interpolate route vars in the redirected path from original search', function() {
       module(function($routeProvider) {
-        $routeProvider.when('/bar/:id/:subid/:subsubid', {template: 'bar.html'});
+        $routeProvider.when('/bar/:id/:subid/:subsubid', {templateUrl: 'bar.html'});
         $routeProvider.when('/foo/:id/:extra', {redirectTo: '/bar/:id/:subid/99'});
       });
 
@@ -278,7 +528,7 @@ describe('$route', function() {
 
         expect($location.path()).toEqual('/bar/id3/sid1/99');
         expect($location.search()).toEqual({appended: 'true', extra: 'eId'});
-        expect($route.current.template).toEqual('bar.html');
+        expect($route.current.templateUrl).toEqual('bar.html');
       });
     });
 
@@ -292,7 +542,7 @@ describe('$route', function() {
       }
 
       module(function($routeProvider){
-        $routeProvider.when('/bar/:id/:subid/:subsubid', {template: 'bar.html'});
+        $routeProvider.when('/bar/:id/:subid/:subsubid', {templateUrl: 'bar.html'});
         $routeProvider.when('/foo/:id', {redirectTo: customRedirectFn});
       });
 
@@ -307,13 +557,16 @@ describe('$route', function() {
 
     it('should replace the url when redirecting',  function() {
       module(function($routeProvider) {
-        $routeProvider.when('/bar/:id', {template: 'bar.html'});
+        $routeProvider.when('/bar/:id', {templateUrl: 'bar.html'});
         $routeProvider.when('/foo/:id/:extra', {redirectTo: '/bar/:id'});
       });
       inject(function($route, $location, $rootScope) {
         var replace;
-        $rootScope.$watch(function() {
-          if (isUndefined(replace)) replace = $location.$$replace;
+
+        $rootScope.$on('$locationChangeStart', function(event, newUrl, oldUrl) {
+          if (oldUrl == 'http://server/#/foo/id3/eId') {
+            replace = $location.$$replace;
+          }
         });
 
         $location.path('/foo/id3/eId');
@@ -335,7 +588,7 @@ describe('$route', function() {
       });
 
       inject(function($route, $location, $rootScope, $routeParams) {
-        $rootScope.$on('$beforeRouteChange', reloaded);
+        $rootScope.$on('$routeChangeStart', reloaded);
         $location.path('/foo');
         $rootScope.$digest();
         expect(reloaded).toHaveBeenCalled();
@@ -360,8 +613,8 @@ describe('$route', function() {
       });
 
       inject(function($route, $location, $rootScope) {
-        $rootScope.$on('$beforeRouteChange', routeChange);
-        $rootScope.$on('$afterRouteChange', routeChange);
+        $rootScope.$on('$routeChangeStart', routeChange);
+        $rootScope.$on('$routeChangeSuccess', routeChange);
         $rootScope.$on('$routeUpdate', routeUpdate);
 
         expect(routeChange).not.toHaveBeenCalled();
@@ -390,8 +643,8 @@ describe('$route', function() {
       });
 
       inject(function($route, $location, $rootScope) {
-        $rootScope.$on('$beforeRouteChange', routeChange);
-        $rootScope.$on('$afterRouteChange', routeChange);
+        $rootScope.$on('$routeChangeStart', routeChange);
+        $rootScope.$on('$routeChangeSuccess', routeChange);
 
         expect(routeChange).not.toHaveBeenCalled();
 
@@ -465,7 +718,7 @@ describe('$route', function() {
         });
 
         inject(function($route, $location, $rootScope, $routeParams) {
-          $rootScope.$on('$afterRouteChange', routeChangeSpy);
+          $rootScope.$on('$routeChangeSuccess', routeChangeSpy);
 
           $location.path('/bar/123');
           $rootScope.$digest();
diff --git a/test/ngMock/angular-mocksSpec.js b/test/ngMock/angular-mocksSpec.js
index 621900723e91..f4f6a34626e1 100644
--- a/test/ngMock/angular-mocksSpec.js
+++ b/test/ngMock/angular-mocksSpec.js
@@ -950,6 +950,13 @@ describe('ngMock', function() {
       });
     });
   });
+
+
+  describe('$rootElement', function() {
+    it('should create mock application root', inject(function($rootElement) {
+      expect($rootElement.text()).toEqual('');
+    }));
+  });
 });