Work around for content select not supporting touch events on it's children.

ui/keyboard/resources/elements/kb-keyboard.html

 <!--
   -- Copyright 2013 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.
   -->
 
 <polymer-element name="kb-keyboard" on-key-over="{{keyOver}}"
     on-key-up="{{keyUp}}" on-key-down="{{keyDown}}"
     on-key-longpress="{{keyLongpress}}" on-pointerup="{{up}}"
     on-pointerdown="{{down}}" on-pointerout="{{out}}"
     on-enable-sel="{{enableSel}}" on-enable-dbl="{{enableDbl}}"
     on-key-out="{{keyOut}}" on-show-options="{{showOptions}}"
     on-set-layout="{{setLayout}}" on-type-key="{{type}}"
     attributes="keyset layout inputType inputTypeToLayoutMap">
   <template>
     <style>
       @host {
         * {
           position: relative;
         }
       }
     </style>
     <!-- The ID for a keyset follows the naming convention of combining the
       -- layout name with a base keyset name. This convention is used to
       -- allow multiple layouts to be loaded (enablign fast switching) while
       -- allowing the shift and spacebar keys to be common across multiple
       -- keyboard layouts.
       -->
-    <content id="content" select="#{{layout}}-{{keyset}}"></content>
+    <content id="content"></content>
     <kb-keyboard-overlay id="overlay" hidden></kb-keyboard-overlay>
     <kb-key-codes id="keyCodeMetadata"></kb-key-codes>
   </template>
   <script>
     /**
      * The repeat delay in milliseconds before a key starts repeating. Use the
      * same rate as Chromebook.
      * (See chrome/browser/chromeos/language_preferences.cc)
      * @const
      * @type {number}
@@ skipping 290 matching lines @@
         }
         var toKeyset = detail.toKeyset;
         if (toKeyset) {
           this.keyset = toKeyset;
           this.activeKeyset.nextKeyset = detail.nextKeyset;
           return true;
         }
         return false;
       },
 
+      keysetChanged: function() {
+        var keyset = this.activeKeyset;
+        // Show the keyset if it has been initialized.
+        if (keyset)
+          keyset.show();
+      },
+
       ready: function() {
         this.voiceInput_ = new VoiceInput(this);
         this.swipeHandler = this.move.bind(this);
       },
 
       /**
-       * Registers a callback for state change events. Lazy initializes a
-       * mutation observer used to detect when the keyset selection is changed.
+       * Registers a callback for state change events.
        * @param{!Function} callback Callback function to register.
        */
       addKeysetChangedObserver: function(callback) {
-        if (!this.keysetChangedObserver) {
-          var target = this.$.content;
-          var self = this;
-          var observer = new MutationObserver(function(mutations) {
-            mutations.forEach(function(m) {
-              if (m.type == 'attributes' && m.attributeName == 'select') {
-                var value = m.target.getAttribute('select');
-                self.fire('stateChange', {
-                  state: 'keysetChanged',
-                  value: value
-                });
-              }
-            });
-          });
-
-          observer.observe(target, {
-            attributes: true,
-            childList: true,
-            subtree: true
-          });
-          this.keysetChangedObserver = observer;
-
-        }
         this.addEventListener('stateChange', callback);
       },
 
       /**
        * Called when the type of focused input box changes. If a keyboard layout
        * is defined for the current input type, that layout will be loaded.
        * Otherwise, the keyboard layout for 'text' type will be loaded.
        */
       inputTypeChanged: function() {
         // TODO(bshe): Toggle visibility of some keys in a keyboard layout
@@ skipping 442 matching lines @@
               document.head.appendChild(link);
 
               // Load content for the new link element.
               var self = this;
               HTMLImports.importer.load(document, function() {
                 HTMLImports.parser.parseLink(link);
                 self.layoutChanged();
               });
             }
           }
+        // New keyset has already been loaded, can show immediately.
+        } else {
+          this.activeKeyset.show();
         }
       },
 
       /**
        * Notifies the modifier keys that a non-control key was typed. This
        * lets them reset sticky behaviour. A non-control key is defined as
        * any key that is not Control, Alt, or Shift.
        */
       onNonControlKeyTyped: function() {
         if (this.shift)
@@ skipping 44 matching lines @@
 
       /**
        * The keyboard is ready for input once the target keyset appears
        * in the distributed nodes for the keyboard.
        * @return {boolean} Indicates if the keyboard is ready for input.
        */
       isReady: function() {
         var keyset =  this.activeKeyset;
         if (!keyset)
           return false;
-        var content = this.$.content.getDistributedNodes()[0];
-        return content == keyset;
+        var nodes = this.$.content.getDistributedNodes();
+        for (var i = 0; i < nodes.length; i++) {
+          if (nodes[i].id && nodes[i].id == keyset.id)
+            return true;
+        }
+        return false;
       },
 
       /**
        * Generates fabricated key events to simulate typing on a
        * physical keyboard.
        * @param {Object} detail Attributes of the key being typed.
        * @return {boolean} Whether the key type succeeded.
        */
       keyTyped: function(detail) {
         var builder = this.$.keyCodeMetadata;
@@ skipping 26 matching lines @@
           var matches = keysets[i].id.match(regex);
           if (matches && matches.length == REGEX_MATCH_COUNT) {
              keysetsLoaded = true;
              // Without both tests for a default keyset, it is possible to get
              // into a state where multiple layouts are displayed.  A
              // reproducable test case is do the following set of keyset
              // transitions: qwerty -> system -> dvorak -> qwerty.
              // TODO(kevers): Investigate why this is the case.
              if (keysets[i].isDefault ||
                  keysets[i].getAttribute('isDefault') == 'true') {
+               var allKeys = keysets[i].querySelectorAll('*').array();

[kevers, 2014/01/17 17:56:35]

childNodes?

Also believe that this code belongs in the keyset expansion code and not here.

[rsadam, 2014/01/17 18:38:48]

Done.

+               for (var j = 0; j< allKeys.length; j++) {
+                 var weight = allKeys[j].getAttribute('weight');
+                 if (weight) {
+                  allKeys[j].style.webkitBoxFlex = weight;
+                 }
+               }
                this.keyset = matches[REGEX_KEYSET_INDEX];
                this.classList.remove('caps-locked');
                this.classList.remove('alt-active');
                this.classList.remove('ctrl-active');
                // Caches shift key.
                this.shift = this.querySelector('kb-shift-key');
                if (this.shift)
                  this.shift.reset();
                // Caches control key.
                this.ctrl = this.querySelector('kb-modifier-key[char=Ctrl]');
@@ skipping 12 matching lines @@
              }
           }
         }
         if (keysetsLoaded)
           console.error('No default keyset found for ' + this.layout);
         return false;
       }
     });
   </script>
 </polymer-element>