Revert 109678 - WebUI test framework: fix Mock4JS verification, allow chrome.send passthrough.

chrome/test/data/webui/test_api.js

 // Copyright (c) 2011 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 Library providing basic test framework functionality.
  */
 
 /**
  * Namespace for |Test|.
  * @type {Object}
  */
 var testing = {};
 (function(exports) {
   /**
-   * Holds the original version of the |chrome| object.
-   */
-  var originalChrome = null;
-
-  /**
    * Hold the currentTestCase across between preLoad and run.
    * @type {TestCase}
    */
   var currentTestCase = null;
 
   /**
    * The string representation of the currently running test function.
    * @type {?string}
    */
   var currentTestFunction = null;
@@ skipping 305 matching lines @@
     sendCallbacks[name] = [messageHandler, callback];
   }
 
   /**
    * Register all methods of {@code mockClass.prototype} with messages of the
    * same name as the method, using the proxy of the |mockObject| as the
    * |messageHandler| when registering.
    * @param {Mock4JS.Mock} mockObject The mock to register callbacks against.
    * @param {function(new:Object)} mockClAss Constructor for the mocked class.
    * @see registerMessageCallback
-   * @see overrideChrome
    */
   function registerMockMessageCallbacks(mockObject, mockClass) {
-    if (!deferGlobalOverrides && !originalChrome)
-      overrideChrome();
     var mockProxy = mockObject.proxy();
     for (var func in mockClass.prototype) {
       if (typeof mockClass.prototype[func] === 'function') {
         registerMessageCallback(func, mockProxy, mockProxy[func]);
       }
     }
   }
 
   /**
    * Holds the mapping of name -> global override information.
@@ skipping 196 matching lines @@
    * @param {Array.<boolean, string>=} result When passed, this is used for the
    *     testResult message.
    */
   function testDone(result) {
     if (!testIsDone) {
       testIsDone = true;
       if (currentTestCase) {
         try {
           currentTestCase.tearDown();
         } catch (e) {
-          // Caught an exception in tearDown; Register the error and recreate
-          // the result if it is passed in.
           errors.push(e);
-          if (result)
-            result = [false, errorsToMessage([e], result[1])];
         }
         currentTestCase = null;
       }
       chrome.send('testResult', result ? result : testResult());
       errors.splice(0, errors.length);
     } else {
       console.warn('testIsDone already');
     }
   }
 
   /**
-   * Converts each Error in |errors| to a suitable message, adding them to
-   * |message|, and returns the message string.
-   * @param {Array.<Error>} errors Array of errors to add to |message|.
-   * @param {string?} message When supplied, error messages are appended to it.
-   * @return {string} |message| + messages of all |errors|.
-   */
-  function errorsToMessage(errors, message) {
-    for (var i = 0; i < errors.length; ++i) {
-      var errorMessage = errors[i].stack || errors[i].message;
-      if (message)
-        message += '\n';
-
-      message += 'Failed: ' + currentTestFunction + '(' +
-          currentTestArguments.map(JSON.stringify) +
-          ')\n' + errorMessage;
-    }
-    return message;
-  }
-
-  /**
    * Returns [success, message] & clears |errors|.
    * @param {boolean} errorsOk When true, errors are ok.
    * @return {Array.<boolean, string>}
    */
   function testResult(errorsOk) {
     var result = [true, ''];
     if (errors.length) {
-      result = [!!errorsOk, errorsToMessage(errors)];
+      var message = '';
+      for (var i = 0; i < errors.length; ++i) {
+        message += 'Failed: ' + currentTestFunction + '(' +
+                   currentTestArguments.map(JSON.stringify) +
+                   ')\n' + errors[i].stack;
+      }
+      result = [!!errorsOk, message];
     }
     return result;
   }
 
   // Asserts.
   // Use the following assertions to verify a condition within a test.
   // If assertion fails, throw an Error with information pertinent to the test.
 
   /**
    * When |test| !== true, aborts the current test.
@@ skipping 219 matching lines @@
    */
   function createTestCase(testFixture, testName) {
     var fixtureConstructor = this[testFixture];
     var testBody = fixtureConstructor.testCaseBodies[testName];
     var fixture = new fixtureConstructor();
     fixture.name = testFixture;
     return new TestCase(testName, fixture, testBody);
   }
 
   /**
-   * Overrides the |chrome| object to enable mocking calls to chrome.send().
-   */
-  function overrideChrome() {
-    if (originalChrome) {
-      console.error('chrome object already overridden');
-      return;
-    }
-
-    originalChrome = chrome;
-    chrome = {
-      __proto__: originalChrome,
-      send: send,
-      originalSend: originalChrome.send.bind(originalChrome),
-    };
-  }
-
-  /**
    * Used by WebUIBrowserTest to preload the javascript libraries at the
    * appropriate time for javascript injection into the current page. This
    * creates a test case and calls its preLoad for any early initialization such
    * as registering handlers before the page's javascript runs it's OnLoad
    * method. This is called before the page is loaded, so the |chrome| object is
    * not yet bound and this DOMContentLoaded listener will be called first to
    * override |chrome| in order to route messages registered in |sendCallbacks|.
    * @param {string} testFixture The test fixture name.
    * @param {string} testName The test name.
    * @see sendCallbacks
    */
   function preloadJavascriptLibraries(testFixture, testName) {
     deferGlobalOverrides = true;
 
-    window.addEventListener('DOMContentLoaded', function() {
-      overrideChrome();
+    exports.addEventListener('DOMContentLoaded', function() {
+      var oldChrome = chrome;
+      chrome = {
+        __proto__: oldChrome,
+        send: send,
+      };
 
       // Override globals at load time so they will be defined.
       assertTrue(deferGlobalOverrides);
       deferGlobalOverrides = false;
       for (var funcName in globalOverrides)
         overrideGlobal(funcName);
     });
     currentTestCase = createTestCase(testFixture, testName);
     currentTestCase.preLoad();
   }
@@ skipping 460 matching lines @@
   exports.DUMMY_URL = DUMMY_URL;
   exports.TEST = TEST;
   exports.TEST_F = TEST_F;
   exports.GEN = GEN;
   exports.GEN_INCLUDE = GEN_INCLUDE;
   exports.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(exports);
 })(this);