Revert of Fix flaky remoting webapp javascript unittest.

remoting/webapp/base/js/dns_blackhole_checker_unittest.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview
  * TODO(garykac): Create interface for SignalStrategy.
  * @suppress {checkTypes|checkVars|reportUnknownTypes|visibility}
  */
 
@@ skipping 56 matching lines @@
 });
 
 QUnit.test('success',
   function(assert) {
     function checkState(state) {
       signalStrategy.setStateForTesting(state);
       sinon.assert.calledWith(onStateChange, state);
       assert.equal(checker.getState(), state);
     }
 
-    return Promise.resolve().then(function() {
+    return base.SpyPromise.run(function() {
       fakeXhr.respond(200);
     }).then(function() {
       sinon.assert.notCalled(onStateChange);
       checkState(remoting.SignalStrategy.State.CONNECTING);
       checkState(remoting.SignalStrategy.State.HANDSHAKE);
       checkState(remoting.SignalStrategy.State.CONNECTED);
     });
   });
 
 QUnit.test('http response after connected',
   function(assert) {
     function checkState(state) {
       signalStrategy.setStateForTesting(state);
       sinon.assert.calledWith(onStateChange, state);
       assert.equal(checker.getState(), state);
     }
 
     checkState(remoting.SignalStrategy.State.CONNECTING);
     checkState(remoting.SignalStrategy.State.HANDSHAKE);
     onStateChange.reset();
 
     // Verify that DnsBlackholeChecker stays in HANDSHAKE state even if the
     // signal strategy has connected.
-    return Promise.resolve().then(function() {
+    return base.SpyPromise.run(function() {
       signalStrategy.setStateForTesting(
           remoting.SignalStrategy.State.CONNECTED);
     }).then(function() {
       sinon.assert.notCalled(onStateChange);
     assert.equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
 
       // Verify that DnsBlackholeChecker goes to CONNECTED state after the
       // the HTTP request has succeeded.
-      return Promise.resolve().then(function() {
+      return base.SpyPromise.run(function() {
         fakeXhr.respond(200);
       });
     }).then(function() {
       sinon.assert.calledWith(onStateChange,
                               remoting.SignalStrategy.State.CONNECTED);
     });
   });
 
 QUnit.test('connect failed',
   function(assert) {
     function checkState(state) {
       signalStrategy.setStateForTesting(state);
       sinon.assert.calledWith(onStateChange, state);
     };
 
-    return Promise.resolve().then(function() {
+    return base.SpyPromise.run(function() {
       fakeXhr.respond(200);
     }).then(function() {
       sinon.assert.notCalled(onStateChange);
       checkState(remoting.SignalStrategy.State.CONNECTING);
       checkState(remoting.SignalStrategy.State.FAILED);
     });
   });
 
 QUnit.test('blocked',
   function(assert) {
     function checkState(state) {
     assert.equal(checker.getError().getTag(),
                  remoting.Error.Tag.NOT_AUTHORIZED);
       onStateChange.reset();
       signalStrategy.setStateForTesting(state);
       sinon.assert.notCalled(onStateChange);
       assert.equal(checker.getState(),
           checker.getState(),
           remoting.SignalStrategy.State.FAILED,
           'checker state is still FAILED');
     };
 
-    return Promise.resolve().then(function() {
+    return base.SpyPromise.run(function() {
       fakeXhr.respond(400);
     }).then(function() {
       sinon.assert.calledWith(
           onStateChange, remoting.SignalStrategy.State.FAILED);
       assert.equal(
           checker.getError().getTag(),
           remoting.Error.Tag.NOT_AUTHORIZED,
           'checker error is NOT_AUTHORIZED');
       checkState(remoting.SignalStrategy.State.CONNECTING);
       checkState(remoting.SignalStrategy.State.HANDSHAKE);
       checkState(remoting.SignalStrategy.State.FAILED);
     });
   });
 
 QUnit.test('blocked after connected',
   function(assert) {
     function checkState(state) {
       signalStrategy.setStateForTesting(state);
       sinon.assert.calledWith(onStateChange, state);
       assert.equal(checker.getState(), state);
     };
 
     checkState(remoting.SignalStrategy.State.CONNECTING);
     checkState(remoting.SignalStrategy.State.HANDSHAKE);
     onStateChange.reset();
 
     // Verify that DnsBlackholeChecker stays in HANDSHAKE state even
     // if the signal strategy has connected.
-    return Promise.resolve().then(function() {
+    return base.SpyPromise.run(function() {
       signalStrategy.setStateForTesting(
           remoting.SignalStrategy.State.CONNECTED);
     }).then(function() {
       sinon.assert.notCalled(onStateChange);
     assert.equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
 
       // Verify that DnsBlackholeChecker goes to FAILED state after it
       // gets the blocked HTTP response.
-      return Promise.resolve().then(function() {
+      return base.SpyPromise.run(function() {
         fakeXhr.respond(400);
       });
     }).then(function() {
       sinon.assert.calledWith(onStateChange,
                               remoting.SignalStrategy.State.FAILED);
     assert.ok(checker.getError().hasTag(remoting.Error.Tag.NOT_AUTHORIZED));
     });
   }
 );
 
 })();