@qooxdoo/framework 7.0.0-beta.5 → 7.0.0-beta.6

package/source/class/qx/test/io/jsonrpc/Client.js

@@ -0,0 +1,267 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with a qx.test.io.request.Xhr transport
+ */
+qx.Class.define("qx.test.io.jsonrpc.Client",
+{
+  extend : qx.dev.unit.TestCase,
+
+  include : [
+    qx.dev.unit.MMock,
+    qx.test.io.MAssert
+  ],
+
+  members : {
+
+    setUp() {
+      this.sinon = qx.dev.unit.Sinon.getSinon();
+      this.setUpRequest();
+      this.setUpFakeTransport();
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    setUpRequest: function () {
+      this.req && this.req.dispose();
+      this.req = new qx.io.request.Xhr();
+      this.req.setUrl("url");
+    },
+
+    setUpFakeTransport: function () {
+      if (this.transport && this.transport.send.restore) {
+        return;
+      }
+      this.transport = this.injectStub(qx.io.request.Xhr.prototype, "_createTransport");
+      this.setUpRequest();
+    },
+
+    setUpFakeXhr: function () {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeXMLHttpRequest();
+      this.setUpRequest();
+    },
+
+    /**
+     * Sets up the fake server and instructs it to send the given response(s)
+     * @param {String} response The server response to the first request
+     */
+    setUpFakeServer: function (response) {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeServer();
+      this.setUpRequest();
+      this.getServer().respondWith(
+        "POST", /.*/,
+        [200, {"Content-Type": "application/json; charset=utf-8"}, response]
+      );
+      this.getServer().autoRespond = true;
+    },
+
+    /**
+     * Assert that the given exception is thrown on receiving the given result
+     * @param {String} response
+     * @param {Class|Number} exception If class, the exception class, which must
+     * be a subclass of qx.io.exception.Exception. If number, the error number
+     */
+    assertExceptionThrown: function (response, exception) {
+      if (!(qx.lang.Type.isNumber(exception) || qx.Class.isSubClassOf(exception, qx.io.exception.Exception))) {
+        throw new Error("Second argument must be a Number or a subclass of qx.io.exception.Exception");
+      }
+      this.setUpFakeServer(response);
+      const message_out = new qx.io.jsonrpc.protocol.Request("foo",[1,2,3]);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      const errorCallback = this.spy(err => {
+        //console.warn(err);
+        if (qx.lang.Type.isNumber(exception)) {
+          if (!(err instanceof qx.io.exception.Exception)) {
+            throw err;
+          }
+          this.assertEquals(exception, err.code,`Error code does not match`);
+        } else {
+          this.assertInstance(err, exception,
+            `Exception class does not match. Expected ${exception.classname}, got ${err}.`);
+        }
+      });
+      // check message promise
+      message_out.getPromise().catch(errorCallback);
+      // check event
+      client.addListener("error", evt => errorCallback(evt.getData()));
+      // check transport promise
+      client.send(message_out).catch(errorCallback);
+      this.wait(100, () => {
+        if (
+          // the request promise will not be called since the promise is already rejected
+          exception === qx.io.exception.Transport.DUPLICATE_ID
+          // or the send promise will not be rejected because we have a server-side error
+          || exception === qx.io.exception.Protocol) {
+          this.assertCalledTwice(errorCallback)
+        } else {
+          // the error handler will be called three times
+          this.assertCalledThrice(errorCallback)
+        }
+      });
+    },
+
+    tearDown: function () {
+      this.getSandbox().restore();
+      this.req.dispose();
+    },
+
+    resetId(){
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    //
+    // Auth, should be moved into qx.test.io.request.Xhr
+    //
+
+    "test: Bearer authentication": function () {
+      this.setUpFakeTransport();
+
+      var transport = this.transport, auth, call, key, credentials;
+
+      auth = new qx.io.request.authentication.Bearer("TOKEN");
+      this.req.setAuthentication(auth);
+      this.req.send();
+
+      call = transport.setRequestHeader.getCall(1);
+      key = "Authorization";
+      credentials = /Bearer\s(.*)/.exec(call.args[1])[1];
+      this.assertEquals(key, call.args[0]);
+      this.assertEquals("TOKEN", credentials);
+    },
+
+    //
+    // JSON-RPC
+    //
+
+    "test: throw on invalid response id" : function() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({"jsonrpc": "2.0", "result": 19, "id": 2});
+      this.assertExceptionThrown(response, qx.io.exception.Transport.UNKNOWN_ID);
+    },
+
+    "test: throw on duplicate response id" : function() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        {"jsonrpc": "2.0", "result": 19, "id": 1},
+        {"jsonrpc": "2.0", "result": 19, "id": 1}
+      ]);
+      this.assertExceptionThrown(response, qx.io.exception.Transport.DUPLICATE_ID);
+    },
+
+    "test: call jsonrpc method and receive response with single result" : async function() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let message_in  = new qx.io.jsonrpc.protocol.Result(message_out.getId(), result);
+      this.setUpFakeServer(message_in.toString());
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    "test: call jsonrpc method and receive batched response" : async function() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let response = (new qx.io.jsonrpc.protocol.Batch())
+        .add(new qx.io.jsonrpc.protocol.Result(message_out.getId(), result))
+        .addRequest("foo", ["bar"])
+        .addNotification("logout")
+        .toString();
+      this.setUpFakeServer(response);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse "() {
+      this.assertExceptionThrown("helloworld!", qx.io.exception.Transport.INVALID_JSON);
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse - missing result" () {
+      this.assertExceptionThrown("null", qx.io.exception.Transport.NO_DATA);
+    },
+
+    "test: call jsonrpc method and expect error response"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({"jsonrpc": "2.0", "error" : {"code": -32600, "message": "Division by zero!"}, "id": 1});
+      this.assertExceptionThrown(response, qx.io.exception.Protocol);
+    },
+
+    "test: send batched requests"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        {"jsonrpc": "2.0", "result": 7, "id": 1},
+        {"jsonrpc": "2.0", "result": "foo", "id": 2},
+        {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": 3},
+        {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": 4},
+        {"jsonrpc": "2.0", "result": ["hello", 5], "id": 5}]);
+      this.setUpFakeServer(response);
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spies = [];
+      var batch = new qx.io.jsonrpc.protocol.Batch();
+      for( var i=1; i < 6; i++) {
+        spies[i] = { result: this.spy(), error: this.spy() };
+        let request = new qx.io.jsonrpc.protocol.Request("someMethod", []);
+        request.getPromise()
+          .then(spies[i].result)
+          .catch(spies[i].error);
+        batch.add(request);
+      }
+      client.sendBatch(batch).catch(err => {
+        this.assertInstance(err, qx.io.exception.Protocol);
+      });
+      this.wait(100, function(){
+        this.assertCalledWith(spies[1].result, 7);
+        this.assertCalledWith(spies[2].result, "foo");
+        this.assertCalled(spies[3].error);
+        this.assertCalled(spies[4].error);
+        this.assertCalledWith(spies[5].result, ["hello", 5]);
+      },this);
+    },
+
+    "test: receive jsonrpc requests from server" : function() {
+      this.resetId();
+      var response = [
+        {"jsonrpc": "2.0", "method": "clientMethod", "params": ["foo", "bar"], "id": 1},
+        {"jsonrpc": "2.0", "method": "clientNotification", "params": []}
+      ];
+      this.setUpFakeServer(qx.lang.Json.stringify(response));
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spy = this.spy();
+      client.addListener("incomingRequest", evt => {
+        let message = evt.getData().toObject();
+        this.assertDeepEquals(response.shift(), message);
+        spy(message);
+      });
+      client.sendNotification("ping");
+      this.wait(100, function(){
+        this.assertCalledTwice(spy);
+      },this);
+    }
+  }
+});

package/source/class/qx/test/io/jsonrpc/Protocol.js

@@ -0,0 +1,80 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+qx.Class.define("qx.test.io.jsonrpc.Protocol",
+{
+  extend : qx.dev.unit.TestCase,
+  include : [qx.test.io.MAssert],
+  construct() {
+    this.base(arguments);
+    this.parser = new qx.io.jsonrpc.protocol.Parser();
+  },
+  members : {
+    "test: JSON-RPC request message object"() {
+      let message = new qx.io.jsonrpc.protocol.Request("foo", ["bar", 1, false]);
+      let expected = {
+        id: 1,
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC request notification object"() {
+      let message = new qx.io.jsonrpc.protocol.Notification("foo", ["bar", 1, false]);
+      let expected = {
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC error object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0",
+        id: 1,
+        error: {
+          code: 5,
+          message: "error!"
+        }
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC result object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0", id: 1, error: {
+          code: 5, message: "error!"
+        }
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    }
+  }
+});

package/source/class/qx/test/io/transport/PostMessage.js

@@ -0,0 +1,56 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for the postMessage transport
+ * @ignore(URL)
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.transport.PostMessage", {
+  extend: qx.dev.unit.TestCase,
+
+  members: {
+
+    setUp() {
+      // see https://medium.com/@dee_bloo/make-multithreading-easier-with-inline-web-workers-a58723428a42
+      function createWorker(fn) {
+        let blob = new Blob(['self.onmessage = ', fn.toString()], { type: 'text/javascript' });
+        return new Worker(URL.createObjectURL(blob));
+      }
+      // create echo server
+      const worker = createWorker(evt => {
+        self.postMessage(evt.data);
+      });
+      this.transport = new qx.io.transport.PostMessage(worker);
+    },
+
+    async "test: send message to worker and check response"() {
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/io/transport/Websocket.js

@@ -0,0 +1,63 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for the websocket transport
+ */
+qx.Class.define("qx.test.io.transport.Websocket", {
+  extend: qx.dev.unit.TestCase,
+
+  statics: {
+    TEST_ENDPOINT: "echo.websocket.events"
+  },
+
+  members: {
+
+    __hasEndpoint : false,
+    __skipMsg: "Skipping test as endpoint is not available.",
+
+    setUp() {
+      this.transport = new qx.io.transport.Websocket("wss://" + this.constructor.TEST_ENDPOINT);
+    },
+
+    async "test: check endpoint"() {
+      try {
+        await this.transport.send("test");
+        this.__hasEndpoint = true;
+      } catch(e) {
+        console.error(`Endpoint ${this.constructor.TEST_ENDPOINT} is not accessible: ${e.message}`);
+      }
+    },
+
+    async "test: send message to public websocket echo server and check response"() {
+      if (!this.__hasEndpoint) {
+        return this.skip(this.__skipMsg);
+      }
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/ui/embed/Iframe.js

@@ -88,6 +88,7 @@ qx.Class.define("qx.test.ui.embed.Iframe",
       this.wait(10000);
     },
 
+    /** @ignore(require) */
     testSyncSourceAfterDOMMove : function ()
     {
       // This breaks (very) frequently when run under headless chrome on Travis; we can't
@@ -99,7 +100,6 @@ qx.Class.define("qx.test.ui.embed.Iframe",
 
       //  This also breaks on MacOS runners on GitHub with webkit
       try {
-        /** @ignore(require) */
         let CI = require("process").env.CI;
         if (CI && qx.core.Environment.get("browser.name") === "webkit") {
           this.skip("Skipping for Webkit for MacOS");

package/source/class/qx/test/util/DateFormat.js

@@ -805,15 +805,54 @@ qx.Class.define("qx.test.util.DateFormat",
         this._testIsoMasks(date, 'isoDate', 'yyyy-MM-dd');
         this._testIsoMasks(date, 'isoTime', 'HH:mm:ss');
         this._testIsoMasks(date, 'isoDateTime', "yyyy-MM-dd'T'HH:mm:ss");
-
-//        var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
-//        var df = new qx.util.format.DateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
-//        var isoDateFormatted = isodf.format(date);
-//        var dateFormatted = df.format(date);
-//        this.assertEquals(isodf.parse(isoDateFormatted).getTime(),df.parse(dateFormatted).getTime());
+        this._testIsoMasks(date, 'isoDateTimeTz', "yyyy-MM-dd'T'HH:mm:ssZ");
+        //this._testIsoMasks(date, 'isoUtcDateTime', "yyyy-MM-dd'T'HH:mm:ss'Z'");
       }
   },
 
+  testIsoTz : function() {
+    var isodf = new qx.util.format.DateFormat('isoDateTimeTz');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00+0000");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    parsedDate = isodf.parse("2004-04-04T04:04:04-0500")
+    this.assertEquals(parsedDate.getUTCFullYear(), 2004);
+    this.assertEquals(parsedDate.getUTCMonth(), 3);
+    this.assertEquals(parsedDate.getUTCDate(), 3);
+    this.assertEquals(parsedDate.getUTCHours(), 23);
+    this.assertEquals(parsedDate.getUTCMinutes(), 4);
+    this.assertEquals(parsedDate.getUTCSeconds(), 4);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+  },
+
+  testUtc : function () {
+    var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00Z");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    // checks that UTC hours are calculated correctly
+    parsedDate = isodf.parse("2004-04-04T04:04:04Z");
+    this.assertEquals(parsedDate.getUTCHours(), 4);
+
+    // checks that UTC format does not parse a date with a timezone
+    this.assertException(function() {
+      isodf.parse("2004-04-04T04:04:04+05:00");
+    }, Error);
+
+  },
+
   testChangingLocales : function()
   {
     var manager = qx.locale.Manager.getInstance();

package/source/class/qx/tool/cli/commands/Compile.js

@@ -571,10 +571,10 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
     createMakersFromConfig: async function(data) {
       const Console = qx.tool.compiler.Console.getInstance();
       var t = this;
-
       if (data.babelOptions) {
-        if (!data.babelConfig) {
-          data.babelConfig = { options: data.babelOptions };
+        if (!data?.babel?.options) {
+          data.babel = data.babel || {};
+          data.babel.options = data.babelOptions;
           qx.tool.compiler.Console.print("qx.tool.cli.compile.deprecatedBabelOptions");
         } else {
           qx.tool.compiler.Console.print("qx.tool.cli.compile.deprecatedBabelOptionsConflicting");

package/source/class/qx/tool/cli/commands/package/Publish.js

@@ -99,6 +99,14 @@ qx.Class.define("qx.tool.cli.commands.package.Publish", {
       };
     }
   },
+  events: {
+    /**
+     * Fired before commit happens. Data is an object with
+     *   version: new_version,
+     *   argv: this.argv
+    */
+    "beforeCommit": "qx.event.type.Data"
+  },
 
   members: {
 
@@ -337,6 +345,12 @@ qx.Class.define("qx.tool.cli.commands.package.Publish", {
         }
       }
 
+      await this.fireDataEventAsync("beforeCommit", {
+        version: new_version,
+        argv: this.argv
+      });
+
+
       if (argv.dryrun) {
         qx.tool.compiler.Console.info(`Dry run: not creating tag and release '${tag}' of ${repo_name}...`);
         return;

package/source/class/qx/tool/compiler/makers/AppMaker.js

@@ -86,7 +86,8 @@ qx.Class.define("qx.tool.compiler.makers.AppMaker", {
         },
         this.getEnvironment(),
         target.getDefaultEnvironment(),
-        target.getEnvironment());
+        target.getEnvironment()
+      );
 
       let preserve = target.getPreserveEnvironment();
       if (preserve) {

package/source/class/qx/tool/compiler/targets/Target.js

@@ -894,7 +894,8 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
           "appPath": t.getProjectDir(application) + "/",
           "preBootJs": "",
           "appTitle": (application.getTitle()||"Qooxdoo Application"),
-          "timeStamp": timeStamp
+          "timeStamp": timeStamp,
+          "indexJsTimestamp": indexJsTimestamp        
         };
         await fs.writeFileAsync(t.getOutputDir() + "index.html", replaceVars(indexHtml), { encoding: "utf8" });
       }

package/source/class/qx/tool/compiler/targets/meta/PolyfillJs.js

@@ -42,11 +42,18 @@ qx.Class.define("qx.tool.compiler.targets.meta.PolyfillJs", {
 
   members: {
 
-    /*
+    /**
      * @Override
      */
     async writeSourceCodeToStream(ws) {
-      const srcFilename = path.join(require.resolve("core-js-bundle"), "../minified.js");
+      await this.__write(path.join(require.resolve("core-js-bundle"), "../minified.js"), ws);
+      await new Promise(resolve => {
+        ws.write("\n", resolve);
+      });
+      await this.__write(path.join(require.resolve("regenerator-runtime"), "../runtime.js"), ws);
+    },
+
+    async __write(srcFilename, ws) {
       let rs = fs.createReadStream(srcFilename, "utf8");
       await new Promise((resolve, reject) => {
         rs.on("end", resolve);
@@ -55,7 +62,8 @@ qx.Class.define("qx.tool.compiler.targets.meta.PolyfillJs", {
       });
     },
 
-    /*
+
+    /**
      * @Override
      */
     async getSourceMap() {

package/source/class/qx/ui/form/ComboBox.js

@@ -337,10 +337,15 @@ qx.Class.define("qx.ui.form.ComboBox",
       }
 
       // Set aria-activedescendant
-      if (current && current[0]) {
-        this.getChildControl("textfield").getContentElement().setAttribute("aria-activedescendant", current[0].getContentElement().getAttribute("id"));
+      const textFieldContentEl = this.getChildControl("textfield").getContentElement();
+      if (!textFieldContentEl) {
+        return;
+      }
+      const currentContentEl = current && current[0] ? current[0].getContentElement() : null;
+      if (currentContentEl) {
+        textFieldContentEl.setAttribute("aria-activedescendant", currentContentEl.getAttribute("id"));
       } else {
-        this.getChildControl("textfield").getContentElement().removeAttribute("aria-activedescendant");
+        textFieldContentEl.removeAttribute("aria-activedescendant");
       }
     },