Remove applyAsync from http

Author: tolyo

src/core/compile/compile.spec.js

@@ -5983,8 +5983,16 @@ describe("$compile", () => {
       });
 
       it("should allow all template URLs by default", async () => {
-        $compile("<div cross-domain-template></div>")($rootScope);
+        $templateCache.set(
+          "http://example.com/should-not-load.html",
+          "<span>example.com/cached-version</span>",
+        );
+        element = $compile("<div cross-domain-template></div>")($rootScope);
         await wait();
+
+        expect(element.outerHTML).toEqual(
+          '<div cross-domain-template=""><span>example.com/cached-version</span></div>',
+        );
         expect(errors.length).toBe(0);
       });
 

src/services/http/http.spec.js

@@ -1127,63 +1127,15 @@ describe("$http", function () {
     });
   });
 
-  describe("useApplyAsync", function () {
-    beforeEach(function () {
-      const injector = createInjector([
-        "ng",
-        function ($httpProvider) {
-          $httpProvider.useApplyAsync(true);
-        },
-      ]);
-      $http = injector.get("$http");
-      $rootScope = injector.get("$rootScope");
-    });
-
-    it("does not resolve promise immediately when enabled", async function () {
-      const resolvedSpy = jasmine.createSpy();
-      $http.get("/mock/hello").then(resolvedSpy);
-      await wait();
-
-      expect(resolvedSpy).not.toHaveBeenCalled();
-    });
-
-    it("resolves promise later when enabled", async function () {
-      const resolvedSpy = jasmine.createSpy();
-      await $http.get("/mock/hello").then(resolvedSpy);
-      await wait();
+  it("calls configured event handlers", async function () {
+    const loadSpy = jasmine.createSpy("load");
 
-      expect(resolvedSpy).toHaveBeenCalled();
+    await $http.get("/mock/hello", {
+      eventHandlers: { load: loadSpy },
     });
 
-    it("defers configured event handlers when enabled", async function () {
-      const loadSpy = jasmine.createSpy("load");
-
-      await $http.get("/mock/hello", {
-        eventHandlers: { load: loadSpy },
-      });
-
-      await wait();
-      expect(loadSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe("provider configuration", function () {
-    it("returns the current deferred response setting", function () {
-      let initial;
-      let updated;
-
-      createInjector([
-        "ng",
-        function ($httpProvider) {
-          initial = $httpProvider.useApplyAsync();
-          $httpProvider.useApplyAsync(true);
-          updated = $httpProvider.useApplyAsync();
-        },
-      ]);
-
-      expect(initial).toBe(false);
-      expect(updated).toBe(true);
-    });
+    await wait();
+    expect(loadSpy).toHaveBeenCalled();
   });
 });
 
@@ -3921,98 +3873,6 @@ describe("http", () => {
 //   });
 // });
 
-// describe("$http with deferred delivery", () => {
-//   let $http;
-//   let $httpBackend;
-//   let $rootScope;
-//   let $browser;
-//   let log;
-
-//   beforeEach(inject([
-//     "$http",
-//     "$httpBackend",
-//     "$rootScope",
-//     "$browser",
-//     "log",
-//     function (http, backend, scope, browser, logger) {
-//       $http = http;
-//       $httpBackend = backend;
-//       $rootScope = scope;
-//       $browser = browser;
-//       spyOn($rootScope, "digest entry").and.callThrough();
-//       spyOn($rootScope, "deferred delivery").and.callThrough();
-//       spyOn($rootScope, "$digest").and.callThrough();
-//       spyOn($browser.defer, "cancel").and.callThrough();
-//       log = logger;
-//     },
-//   ]));
-
-//   it("should schedule coalesced apply on response", () => {
-//     const handler = jasmine.createSpy("handler");
-//     $httpBackend
-//       .expect("GET", "/template1.html")
-//       .respond(200, "<h1>Header!</h1>", {});
-//     $http.get("/template1.html").then(handler);
-//     // Ensure requests are sent
-//     ;
-
-//     $httpBackend.flush(null, null, false);
-//     expect($rootScope.deferred delivery).toHaveBeenCalled();
-//     expect(handler).not.toHaveBeenCalled();
-
-//     $browser.defer.flush();
-//     expect(handler).toHaveBeenCalled();
-//   });
-
-//   it("should combine multiple responses within short time frame into a single digest entry", () => {
-//     $httpBackend
-//       .expect("GET", "/template1.html")
-//       .respond(200, "<h1>Header!</h1>", {});
-//     $httpBackend
-//       .expect("GET", "/template2.html")
-//       .respond(200, "<p>Body!</p>", {});
-
-//     $http.get("/template1.html").then(log.fn("response 1"));
-//     $http.get("/template2.html").then(log.fn("response 2"));
-//     // Ensure requests are sent
-//     ;
-
-//     $httpBackend.flush(null, null, false);
-//     expect(log).toEqual([]);
-
-//     $browser.defer.flush();
-//     expect(log).toEqual(["response 1", "response 2"]);
-//   });
-
-//   it("should handle pending responses immediately if a digest occurs on $rootScope", () => {
-//     $httpBackend
-//       .expect("GET", "/template1.html")
-//       .respond(200, "<h1>Header!</h1>", {});
-//     $httpBackend
-//       .expect("GET", "/template2.html")
-//       .respond(200, "<p>Body!</p>", {});
-//     $httpBackend
-//       .expect("GET", "/template3.html")
-//       .respond(200, "<p>Body!</p>", {});
-
-//     $http.get("/template1.html").then(log.fn("response 1"));
-//     $http.get("/template2.html").then(log.fn("response 2"));
-//     $http.get("/template3.html").then(log.fn("response 3"));
-//     // Ensure requests are sent
-//     ;
-
-//     // Intermediate $digest occurs before 3rd response is received, assert that pending responses
-//     /// are handled
-//     $httpBackend.flush(2);
-//     expect(log).toEqual(["response 1", "response 2"]);
-
-//     // Finally, third response is received, and a second coalesced digest entry is started
-//     $httpBackend.flush(null, null, false);
-//     $browser.defer.flush();
-//     expect(log).toEqual(["response 1", "response 2", "response 3"]);
-//   });
-// });
-
 // describe("$http param serializers", () => {
 //   let defSer;
 //   let jqrSer;

src/services/http/http.ts

@@ -535,29 +535,6 @@ export function HttpProvider(this: any): void {
     paramSerializer: _httpParamSerializer,
   });
 
-  let useApplyAsync = false;
-
-  /**
-   * Configure $http service to defer processing of responses received at around the
-   * same time. This can reduce repeated response work for applications that make
-   * many HTTP requests concurrently (common during application bootstrap).
-   *
-   * Defaults to false. If no value is specified, returns the current configured value.
-   *
-   * @param value - If true, completed requests are deferred to the next tick.
-   *
-   * @returns The `$httpProvider` for chaining when setting a value, otherwise the current flag.
-   */
-  this.useApplyAsync = function (value?: boolean) {
-    if (isDefined(value)) {
-      useApplyAsync = !!value;
-
-      return this;
-    }
-
-    return useApplyAsync;
-  };
-
   /**
    * Array containing service factories for all synchronous or asynchronous `$http`
    * pre-processing of request or postprocessing of responses.
@@ -1015,45 +992,37 @@ export function HttpProvider(this: any): void {
             config.timeout,
             config.withCredentials,
             config.responseType as XMLHttpRequestResponseType | undefined,
-            createApplyHandlers(config.eventHandlers),
-            createApplyHandlers(config.uploadEventHandlers),
+            createEventHandlers(config.eventHandlers),
+            createEventHandlers(config.uploadEventHandlers),
           );
         }
 
         return promise;
 
-        /** Wraps raw XHR event handlers so optional deferred delivery is consistent. */
-        function createApplyHandlers(
+        /** Wraps raw XHR event handlers with function/object listener support. */
+        function createEventHandlers(
           eventHandlers:
             | RequestConfig["eventHandlers"]
             | RequestConfig["uploadEventHandlers"],
         ): Record<string, EventListener> {
           if (eventHandlers) {
-            const applyHandlers: Record<string, EventListener> = {};
+            const handlers: Record<string, EventListener> = {};
 
             entries(eventHandlers).forEach(([key, eventHandler]) => {
-              applyHandlers[key] = function (event: Event) {
-                if (useApplyAsync) {
-                  setTimeout(() => callEventHandler());
-                } else {
-                  callEventHandler();
-                }
-
-                function callEventHandler() {
-                  if (isFunction(eventHandler)) {
-                    eventHandler(event);
-                  } else if (
-                    eventHandler &&
-                    typeof eventHandler === "object" &&
-                    "handleEvent" in eventHandler
-                  ) {
-                    (eventHandler as EventListenerObject).handleEvent(event);
-                  }
+              handlers[key] = function (event: Event) {
+                if (isFunction(eventHandler)) {
+                  eventHandler(event);
+                } else if (
+                  eventHandler &&
+                  typeof eventHandler === "object" &&
+                  "handleEvent" in eventHandler
+                ) {
+                  (eventHandler as EventListenerObject).handleEvent(event);
                 }
               };
             });
 
-            return applyHandlers;
+            return handlers;
           } else {
             return {};
           }
@@ -1082,21 +1051,13 @@ export function HttpProvider(this: any): void {
             }
           }
 
-          function resolveHttpPromise() {
-            resolvePromise(
-              response,
-              status,
-              headersString,
-              statusText,
-              xhrStatus,
-            );
-          }
-
-          if (useApplyAsync) {
-            setTimeout(resolveHttpPromise);
-          } else {
-            resolveHttpPromise();
-          }
+          resolvePromise(
+            response,
+            status,
+            headersString,
+            statusText,
+            xhrStatus,
+          );
         }
 
         /** Resolves or rejects the raw `$http` promise from a low-level XHR callback payload. */