Uprev Google Input Tools.

third_party/google_input_tools/src/chrome/os/inputview/controller.js

 // Copyright 2014 The ChromeOS IME Authors. All Rights Reserved.
 // limitations under the License.
 // See the License for the specific language governing permissions and
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // distributed under the License is distributed on an "AS-IS" BASIS,
 // Unless required by applicable law or agreed to in writing, software
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // You may obtain a copy of the License at
 // you may not use this file except in compliance with the License.
 // Licensed under the Apache License, Version 2.0 (the "License");
 //
 goog.provide('i18n.input.chrome.inputview.Controller');
 
 goog.require('goog.Disposable');
 goog.require('goog.Timer');
 goog.require('goog.array');
 goog.require('goog.async.Delay');
-goog.require('goog.dom');
 goog.require('goog.dom.classlist');
+goog.require('goog.events.Event');
 goog.require('goog.events.EventHandler');
 goog.require('goog.events.EventType');
 goog.require('goog.i18n.bidi');
 goog.require('goog.object');
 goog.require('i18n.input.chrome.DataSource');
 goog.require('i18n.input.chrome.Statistics');
 goog.require('i18n.input.chrome.inputview.Adapter');
 goog.require('i18n.input.chrome.inputview.CandidatesInfo');
 goog.require('i18n.input.chrome.inputview.ConditionName');
 goog.require('i18n.input.chrome.inputview.Css');
@@ skipping 421 matching lines @@
           i18n.input.chrome.inputview.events.EventType.CONTEXT_BLUR,
           this.onContextBlur_).
       listen(this.adapter_,
           i18n.input.chrome.inputview.events.EventType.VISIBILITY_CHANGE,
           this.onVisibilityChange_).
       listen(this.adapter_,
           i18n.input.chrome.inputview.events.EventType.SETTINGS_READY,
           this.onSettingsReady_).
       listen(this.adapter_, Type.UPDATE_SETTINGS, this.onUpdateSettings_).
       listen(this.adapter_, Type.FRONT_TOGGLE_LANGUAGE_STATE,
-             this.onUpdateToggleLanguateState_);
+          this.onUpdateToggleLanguateState_).
+      listen(this.adapter_, Type.VOICE_STATE_CHANGE, this.onVoiceStateChange_);
 };
 
 
+/**
+ * Handler for voice module state change.
+ *
+ * @param {!i18n.input.chrome.message.Event} e .
+ * @private
+ */
+Controller.prototype.onVoiceStateChange_ = function(e) {
+  var elem = this.container_.getElement();
+  if (!e.msg[Name.VOICE_STATE]) {
+    this.container_.candidateView.switchToIcon(
+        CandidateView.IconType.VOICE, true);
+    this.container_.voiceView.stop();
+  }
+};
+
+
+/**
+ * Sets the default keyset for context types.
+ *
+ * @param {string} newKeyset .
+ * @private
+ */
+Controller.prototype.setDefaultKeyset_ = function(newKeyset) {
+  var keysetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
+  for (var context in keysetMap) {
+    if (context != ContextType.DEFAULT &&
+        keysetMap[context] == keysetMap[ContextType.DEFAULT]) {
+      keysetMap[context] = newKeyset;
+    }
+  }
+  keysetMap[ContextType.DEFAULT] = this.initialKeyset_ = newKeyset;
+};
+
+
 /**
  * Callback for updating settings.
  *
  * @param {!i18n.input.chrome.message.Event} e .
  * @private
  */
 Controller.prototype.onUpdateSettings_ = function(e) {
   var settings = this.model_.settings;
   if (goog.isDef(e.msg['autoSpace'])) {
     settings.autoSpace = e.msg['autoSpace'];
   }
   if (goog.isDef(e.msg['autoCapital'])) {
     settings.autoCapital = e.msg['autoCapital'];
   }
   if (goog.isDef(e.msg['candidatesNavigation'])) {
     settings.candidatesNavigation = e.msg['candidatesNavigation'];
   }
   if (goog.isDef(e.msg[Name.KEYSET])) {
-    this.contextTypeToKeysetMap_[this.currentInputMethod_][
-        ContextType.DEFAULT] = this.initialKeyset_ = e.msg[Name.KEYSET];
+    this.setDefaultKeyset_(e.msg[Name.KEYSET]);
   }
   if (goog.isDef(e.msg['enableLongPress'])) {
     settings.enableLongPress = e.msg['enableLongPress'];
   }
   if (goog.isDef(e.msg['doubleSpacePeriod'])) {
     settings.doubleSpacePeriod = e.msg['doubleSpacePeriod'];
   }
   if (goog.isDef(e.msg['soundOnKeypress'])) {
     settings.soundOnKeypress = e.msg['soundOnKeypress'];
     this.soundController_.setEnabled(settings.soundOnKeypress);
   }
   this.perfTracker_.tick(PerfTracker.TickName.BACKGROUND_SETTINGS_FETCHED);
   this.model_.stateManager.contextType = this.adapter_.contextType;
-  this.switchToKeyset(this.getActiveKeyset_());
+  this.maybeCreateViews_();
 };
 
 
 /**
  * Callback for setting ready.
  *
  * @private
  */
 Controller.prototype.onSettingsReady_ = function() {
   if (this.isSettingReady) {
     return;
   }
 
   this.isSettingReady = true;
   var keysetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
+  var newKeyset = '';
   if (this.adapter_.isA11yMode) {
-    keysetMap[ContextType.PASSWORD] = keysetMap[ContextType.DEFAULT] =
-        util.getConfigName(keysetMap[ContextType.DEFAULT]);
+    newKeyset = util.getConfigName(keysetMap[ContextType.DEFAULT]);
   } else {
-    var preferredKeyset = /** @type {string} */ (this.model_.settings.
+    newKeyset = /** @type {string} */ (this.model_.settings.
         getPreference(util.getConfigName(keysetMap[ContextType.DEFAULT])));
-    if (preferredKeyset) {
-      keysetMap[ContextType.PASSWORD] = keysetMap[ContextType.DEFAULT] =
-          preferredKeyset;
-    }
   }
   if (!this.adapter_.isExperimental && keysetMap[ContextType.DEFAULT] ==
       'zhuyin.compact.qwerty') {
-    keysetMap[ContextType.DEFAULT] = 'zhuyin';
+    newKeyset = 'zhuyin';
   }
-  this.initialKeyset_ = keysetMap[ContextType.DEFAULT];
+  if (newKeyset) {
+    this.setDefaultKeyset_(newKeyset);
+  }
+  // Loads resources in case the default keyset is changed.
+  this.loadAllResources_();
   this.maybeCreateViews_();
 };
 
 
 /**
  * Gets the data for spatial module.
  *
  * @param {!content.SoftKey} key .
  * @param {number} x The x-offset of the touch point.
  * @param {number} y The y-offset of the touch point.
@@ skipping 191 matching lines @@
 
 
 /**
  * Handles the pointer action.
  *
  * @param {!i18n.input.chrome.inputview.elements.Element} view The view.
  * @param {!i18n.input.chrome.inputview.events.PointerEvent} e .
  * @private
  */
 Controller.prototype.handlePointerAction_ = function(view, e) {
+  // Listen for DOUBLE_CLICK as well to capture secondary taps on the spacebar.
+  if (e.type == EventType.POINTER_UP || e.type == EventType.DOUBLE_CLICK) {
+    this.recordStatsForClosing_(
+        'InputMethod.VirtualKeyboard.TapCount', 1, 4095, 4096);
+  }
+
   if (e.type == i18n.input.chrome.inputview.events.EventType.SWIPE) {
     e = /** @type {!i18n.input.chrome.inputview.events.SwipeEvent} */ (e);
     this.handleSwipeAction_(view, e);
   }
   switch (view.type) {
     case ElementType.BACK_BUTTON:
       if (e.type == EventType.POINTER_OUT || e.type == EventType.POINTER_UP) {
         view.setHighlighted(false);
       } else if (e.type == EventType.POINTER_DOWN ||
           e.type == EventType.POINTER_OVER) {
@@ skipping 54 matching lines @@
         }
         view.hide();
         this.clearUnstickyState_();
         this.soundController_.onKeyUp(view.type);
       }
       return;
 
     case ElementType.MENU_ITEM:
       view = /** @type {!content.MenuItem} */ (view);
       if (e.type == EventType.CLICK) {
-        this.resetAll_();
         this.executeCommand_.apply(this, view.getCommand());
         this.container_.menuView.hide();
         this.soundController_.onKeyUp(view.type);
+        this.resetAll_();
       }
       view.setHighlighted(e.type == EventType.POINTER_DOWN ||
           e.type == EventType.POINTER_OVER);
       // TODO: Add chrome vox support.
       return;
 
     case ElementType.MENU_VIEW:
       view = /** @type {!MenuView} */ (view);
 
       if (e.type == EventType.POINTER_DOWN &&
           e.target == view.getCoverElement()) {
         view.hide();
       }
       return;
 
     case ElementType.EMOJI_KEY:
-      if (e.type == EventType.POINTER_UP) {
+      if (e.type == EventType.CLICK) {
         if (!this.container_.currentKeysetView.isDragging && view.text != '') {
           this.adapter_.commitText(view.text);
           this.soundController_.onKeyUp(view.type);
         }
       }
       return;
 
     case ElementType.HWT_PRIVACY_GOT_IT:
-      this.adapter_.sendHwtPrivacyConfirmMessage();
+      // Broadcasts the handwriting privacy confirmed message to let canvas
+      // view handle it.
+      this.adapter_.dispatchEvent(new goog.events.Event(
+          Type.HWT_PRIVACY_GOT_IT));
+      return;
+
+    case ElementType.VOICE_PRIVACY_GOT_IT:
+      // Broadcasts the voice privacy confirmed message to let voice
+      // view handle it.
+      this.adapter_.dispatchEvent(new goog.events.Event(
+          Type.VOICE_PRIVACY_GOT_IT));
+      return;
+
+    case ElementType.VOICE_BTN:
+      if (e.type == EventType.CLICK) {
+        this.container_.candidateView.switchToIcon(
+            CandidateView.IconType.VOICE, false);
+        this.container_.voiceView.start();
+      }
+      return;
+
+
+    case ElementType.VOICE_VIEW:
+      if (e.type == EventType.POINTER_UP) {
+        this.adapter_.sendVoiceViewStateChange(false);
+        this.container_.candidateView.switchToIcon(
+            CandidateView.IconType.VOICE, true);
+        this.container_.voiceView.stop();
+      }
       return;
 
     case ElementType.SOFT_KEY_VIEW:
       // Delegates the events on the soft key view to its soft key.
       view = /** @type {!i18n.input.chrome.inputview.elements.layout.
           SoftKeyView} */ (view);
       if (!view.softKey) {
         return;
       }
       view = view.softKey;
@@ skipping 36 matching lines @@
       break;
     case ElementType.CANDIDATES_PAGE_DOWN:
       if (e.type == EventType.POINTER_UP) {
         this.container_.expandedCandidateView.pageDown();
       }
       break;
     case ElementType.CHARACTER_KEY:
       key = /** @type {!content.CharacterKey} */ (softKey);
       if (e.type == EventType.LONG_PRESS) {
         this.container_.altDataView.show(
-            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_),
-            this.adapter_.isExperimental);
+            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_));
       } else if (e.type == EventType.POINTER_UP) {
         this.model_.stateManager.triggerChording();
         var ch = key.getActiveCharacter();
         this.adapter_.sendKeyDownAndUpEvent(ch, key.id, key.keyCode,
             this.getSpatialData_(key, e.x, e.y));
         this.clearUnstickyState_();
         key.flickerredCharacter = '';
       }
       break;
 
@@ skipping 124 matching lines @@
               util.getConfigName(key.toKeyset),
               key.toKeyset);
         }
       }
       break;
 
     case ElementType.COMPACT_KEY:
       key = /** @type {!content.CompactKey} */ (softKey);
       if (e.type == EventType.LONG_PRESS) {
         this.container_.altDataView.show(
-            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_),
-            this.adapter_.isExperimental);
+            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_));
       } else if (e.type == EventType.POINTER_UP) {
         this.model_.stateManager.triggerChording();
         var ch = key.getActiveCharacter();
         if (ch.length == 1) {
           this.adapter_.sendKeyDownAndUpEvent(key.getActiveCharacter(), '', 0,
               this.getSpatialData_(key, e.x, e.y));
         } else if (ch.length > 1) {
           // Some compact keys contains more than 1 characters, such as '.com',
           // 'http://', etc. Those keys should trigger a direct commit text
           // instead of key events.
           this.adapter_.commitText(ch);
         }
         this.clearUnstickyState_();
         key.flickerredCharacter = '';
       }
       break;
 
     case ElementType.HIDE_KEYBOARD_KEY:
       var defaultKeyset = this.getActiveKeyset_();
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.hideKeyboard();
-      }
-      if (this.currentKeyset_ != defaultKeyset) {
-        this.switchToKeyset(defaultKeyset);
+        if (this.currentKeyset_ != defaultKeyset) {
+          this.switchToKeyset(defaultKeyset);
+        }
       }
       break;
 
     case ElementType.MENU_KEY:
       key = /** @type {!content.MenuKey} */ (softKey);
       if (e.type == EventType.POINTER_DOWN) {
         var isCompact = this.currentKeyset_.indexOf('compact') != -1;
         // Gets the default full keyboard instead of default keyset because
         // the default keyset can be a compact keyset which would cause problem
         // in MenuView.show().
         var defaultFullKeyset = this.initialKeyset_.split(/\./)[0];
         var enableCompact = !this.adapter_.isA11yMode && goog.array.contains(
             util.KEYSETS_HAVE_COMPACT, defaultFullKeyset);
         if (defaultFullKeyset == 'zhuyin' && !this.adapter_.isExperimental ||
             this.languageCode_ == 'ko') {
           // Hides 'switch to compact' for zhuyin when not in experimental env.
           enableCompact = false;
         }
         var self = this;
         var hasHwt = !this.adapter_.isPasswordBox() &&
             !Controller.DISABLE_HWT && goog.object.contains(
-            InputToolCode, this.getHwtInputToolCode_()) &&
-            this.languageCode_ != 'ko';
+            InputToolCode, this.getHwtInputToolCode_());
         var hasEmoji = !this.adapter_.isPasswordBox();
         var enableSettings = this.shouldEnableSettings() &&
             !!window.inputview && !!inputview.openSettings;
         this.adapter_.getInputMethods(function(inputMethods) {
           this.container_.menuView.show(key, defaultFullKeyset, isCompact,
               enableCompact, this.currentInputMethod_, inputMethods, hasHwt,
               enableSettings, hasEmoji);
         }.bind(this));
       }
       break;
@@ skipping 106 matching lines @@
 Controller.prototype.resetAll_ = function() {
   this.clearCandidates_();
   this.container_.cleanStroke();
   this.model_.stateManager.reset();
   this.container_.update();
   this.updateContextModifierState_();
   this.deadKey_ = '';
   this.resize();
   this.container_.expandedCandidateView.close();
   this.container_.menuView.hide();
+  this.container_.altDataView.hide();
 };
 
 
 /**
  * Callback when the context is changed.
  *
  * @private
  */
 Controller.prototype.onContextFocus_ = function() {
   this.resetAll_();
@@ skipping 24 matching lines @@
   }
 };
 
 
 /**
  * Callback for Context blurs.
  *
  * @private
  */
 Controller.prototype.onContextBlur_ = function() {
-  this.clearCandidates_();
   this.container_.cleanStroke();
   this.deadKey_ = '';
   this.container_.menuView.hide();
 };
 
 
 /**
  * Backspace key is down.
  *
  * @private
@@ skipping 150 matching lines @@
  */
 Controller.prototype.clearCandidates_ = function() {
   this.candidatesInfo_ = i18n.input.chrome.inputview.CandidatesInfo.getEmpty();
   this.container_.candidateView.clearCandidates();
   this.container_.expandedCandidateView.close();
   this.container_.expandedCandidateView.state = ExpandedCandidateView.State.
       NONE;
   if (this.container_.currentKeysetView) {
     this.container_.currentKeysetView.setVisible(true);
   }
-  this.container_.candidateView.switchToIcon(CandidateView.IconType.BACK,
-      Controller.HANDWRITING_VIEW_CODE_ == this.currentKeyset_);
+  if (this.currentKeyset_ == Controller.HANDWRITING_VIEW_CODE_) {
+    this.container_.candidateView.switchToIcon(
+        CandidateView.IconType.BACK, true);
+  } else {
+    this.container_.candidateView.switchToIcon(CandidateView.IconType.VOICE,
+        this.currentKeyset_ != Controller.EMOJI_VIEW_CODE_ &&
+            this.adapter_.isExperimental);
+  }
 };
 
 
 /**
  * Callback when the layout is loaded.
  *
  * @param {!i18n.input.chrome.inputview.events.LayoutLoadedEvent} e The event.
  * @private
  */
 Controller.prototype.onLayoutLoaded_ = function(e) {
@@ skipping 44 matching lines @@
 /**
  * Creates the whole view.
  *
  * @private
  */
 Controller.prototype.maybeCreateViews_ = function() {
   if (!this.isSettingReady) {
     return;
   }
 
-  var activeKeyset = this.getActiveKeyset_();
+  // Emoji is temp keyset which is delay loaded. So active keyset can be 'us'
+  // while current keyset is 'emoji'. To make sure delay load can work
+  // correctly, here need to create/switch to 'emoji' instead of 'us'.
+  var activeKeyset = (this.currentKeyset_ == Controller.EMOJI_VIEW_CODE_) ?
+      this.currentKeyset_ : this.getActiveKeyset_();
   var remappedActiveKeyset = this.getRemappedKeyset_(activeKeyset);
+  var created = false;
   if (this.keysetDataMap_[remappedActiveKeyset]) {
     this.createView_(remappedActiveKeyset);
     this.switchToKeyset(activeKeyset);
+    created = true;
   }
   // Async creating the non-active keysets to reduce the latency of showing the
   // active keyset.
-  goog.Timer.callOnce((function() {
-    for (var keyset in this.keysetDataMap_) {
-      if (keyset != remappedActiveKeyset) {
+  var keyLen = Object.keys(this.keysetDataMap_).length;
+  if (created && keyLen > 1 || !created && keyLen > 0) {
+    goog.Timer.callOnce((function() {
+      for (var keyset in this.keysetDataMap_) {
         this.createView_(keyset);
       }
-    }
-  }).bind(this));
+    }).bind(this));
+  }
 };
 
 
 /**
  * Switch to a specific keyboard.
  *
  * @param {string} keyset The keyset name.
  */
 Controller.prototype.switchToKeyset = function(keyset) {
   if (!this.isSettingReady || this.adapter_.isSwitching()) {
     return;
   }
 
   var contextType = this.adapter_.contextType;
   var lastKeysetView = this.container_.currentKeysetView;
   var ret = this.container_.switchToKeyset(this.getRemappedKeyset_(keyset),
       this.title_, this.adapter_.isPasswordBox(), this.adapter_.isA11yMode,
       keyset, this.contextTypeToLastKeysetMap_[contextType] ||
       this.getActiveKeyset_(), this.languageCode_);
 
   if (ret) {
     if (!this.isSubKeyset_(this.currentKeyset_, keyset) &&
         keyset != Controller.EMOJI_VIEW_CODE_) {
       // If it is the sub keyset switching, or emoji, don't record it.
       // Update the keyset of current context type.
       this.contextTypeToKeysetMap_[this.currentInputMethod_][contextType] =
           keyset;
     }
     this.updateLanguageState_(this.currentKeyset_, keyset);
+    this.currentKeyset_ = keyset;
     this.resize(Controller.DEV);
     this.statistics_.recordLayout(keyset, this.adapter_.isA11yMode);
-    this.currentKeyset_ = keyset;
     this.perfTracker_.tick(PerfTracker.TickName.KEYBOARD_SHOWN);
     this.perfTracker_.stop();
   } else {
     // Sets the current keyset for delay switching.
-    this.contextTypeToKeysetMap_[this.currentInputMethod_][contextType] =
-        this.currentKeyset_ = keyset;
+    this.currentKeyset_ = keyset;
+    if (keyset != Controller.EMOJI_VIEW_CODE_) {  // Emoji is temp keyset.
+      this.contextTypeToKeysetMap_[this.currentInputMethod_][contextType] =
+          keyset;
+    }
     this.loadResource_(keyset);
   }
 };
 
 
 /**
  * Callback when the configuration is loaded.
  *
  * @param {!i18n.input.chrome.inputview.events.ConfigLoadedEvent} e The event.
  * @private
  */
 Controller.prototype.onConfigLoaded_ = function(e) {
   if (this.isDisposed()) {
     return;
   }
   var data = e.data;
   var keyboardCode = data[i18n.input.chrome.inputview.SpecNodeName.ID];
   this.keysetDataMap_[keyboardCode] = data;
   this.perfTracker_.tick(PerfTracker.TickName.KEYSET_LOADED);
   var context = data[i18n.input.chrome.inputview.SpecNodeName.ON_CONTEXT];
   if (context && !this.adapter_.isA11yMode) {
     var keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
     if (!keySetMap) {
       keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_] = {};
     }
     keySetMap[context] = keyboardCode;
   }
 
   var layoutId = data[i18n.input.chrome.inputview.SpecNodeName.LAYOUT];
+  if (this.adapter_.isQPInputView && layoutId == 'compactkbd-qwerty') {
+    layoutId = 'm-' + layoutId;
+    data[i18n.input.chrome.inputview.SpecNodeName.LAYOUT] = layoutId;
+  }
   var layoutData = this.layoutDataMap_[layoutId];
   if (layoutData) {
     this.maybeCreateViews_();
   } else {
-    this.model_.loadLayout(data[i18n.input.chrome.inputview.SpecNodeName.
-        LAYOUT]);
+    this.model_.loadLayout(layoutId);
   }
 };
 
 
 /**
  * Resizes the whole UI.
  *
  * @param {boolean=} opt_ignoreWindowResize .
  */
 Controller.prototype.resize = function(opt_ignoreWindowResize) {
   var height;
   var widthPercent;
   var candidateViewHeight;
-  var isHorizontal = screen.width > screen.height;
+  var isLandScape = screen.width > screen.height;
+  if (isLandScape) {
+    goog.dom.classlist.addRemove(this.container_.getElement(),
+        Css.PORTRAIT, Css.LANDSCAPE);
+  } else {
+    goog.dom.classlist.addRemove(this.container_.getElement(),
+        Css.LANDSCAPE, Css.PORTRAIT);
+  }
   var isWideScreen = (Math.min(screen.width, screen.height) / Math.max(
       screen.width, screen.height)) < 0.6;
-  this.model_.stateManager.covariance.update(isWideScreen, isHorizontal,
+  this.model_.stateManager.covariance.update(isWideScreen, isLandScape,
       this.adapter_.isA11yMode);
   if (this.adapter_.isA11yMode) {
     height = SizeSpec.A11Y_HEIGHT;
     widthPercent = screen.width > screen.height ? SizeSpec.A11Y_WIDTH_PERCENT.
         LANDSCAPE : SizeSpec.A11Y_WIDTH_PERCENT.PORTRAIT;
     candidateViewHeight = SizeSpec.A11Y_CANDIDATE_VIEW_HEIGHT;
   } else {
     var keyset = this.keysetDataMap_[this.currentKeyset_];
     var layout = keyset && keyset[SpecNodeName.LAYOUT];
     var data = layout && this.layoutDataMap_[layout];
     var spec = data && data[SpecNodeName.WIDTH_PERCENT] ||
         SizeSpec.NON_A11Y_WIDTH_PERCENT;
     height = SizeSpec.NON_A11Y_HEIGHT;
-    if (isHorizontal) {
+    if (isLandScape) {
       if (isWideScreen) {
-        widthPercent = spec.LANDSCAPE_WIDE_SCREEN;
+        widthPercent = spec['LANDSCAPE_WIDE_SCREEN'];
       } else {
-        widthPercent = spec.LANDSCAPE;
+        widthPercent = spec['LANDSCAPE'];
       }
     } else {
-      widthPercent = spec.PORTRAIT;
+      widthPercent = spec['PORTRAIT'];
     }
     candidateViewHeight = SizeSpec.NON_A11Y_CANDIDATE_VIEW_HEIGHT;
   }
 
-  var viewportSize = goog.dom.getViewportSize();
-  if (viewportSize.height != height && !opt_ignoreWindowResize) {
+  if (window.innerHeight != height && !opt_ignoreWindowResize) {
     if (this.lastResizeHeight_ != height) {
       this.lastResizeHeight_ = height;
       window.resizeTo(screen.width, height);
     }
     return;
   }
 
   this.container_.resize(screen.width, height, widthPercent,
       candidateViewHeight);
   if (this.container_.currentKeysetView) {
@@ skipping 19 matching lines @@
 
 /**
  * Gets the remapped keyset.
  *
  * @param {string} keyset .
  * @return {string} The remapped keyset.
  * @private
  */
 Controller.prototype.getRemappedKeyset_ = function(keyset) {
   if (goog.array.contains(util.KEYSETS_USE_US, keyset)) {
-    return 'us';
+    return 'us-ltr';
   }
   var match = keyset.match(/^(.*)-rtl$/);
   if (match && goog.array.contains(util.KEYSETS_USE_US, match[1])) {
     return 'us-rtl';
   }
   return keyset;
 };
 
 
 /**
@@ skipping 35 matching lines @@
   this.perfTracker_.restart();
   this.adapter_.getCurrentInputMethod(function(currentInputMethod) {
     // TODO: remove this hack as soon as the manifest is fixed in chromium.
     if (languageCode == 'ko') {
       if (currentInputMethod.indexOf('hangul_2set') > 0) {
         keyset = 'm17n:ko_2set';
       }
     }
     this.languageCode_ = languageCode;
     this.currentInputMethod_ = currentInputMethod;
-    var keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
-    if (!keySetMap) {
-      keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_] = {};
-    }
+    var keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_] = {};
     keySetMap[ContextType.PASSWORD] = passwordLayout;
     keySetMap[ContextType.DEFAULT] = keyset;
 
     this.initialKeyset_ = keyset;
     this.title_ = title;
     this.isSettingReady = false;
     this.model_.settings = new i18n.input.chrome.inputview.Settings();
     this.model_.stateManager.isEnMode = false;
     this.adapter_.initialize(languageCode ? languageCode.split('-')[0] : '');
     this.loadAllResources_();
@@ skipping 79 matching lines @@
 Controller.prototype.updateLanguageState_ =
     function(fromRawKeyset, toRawKeyset) {
   var toggle = false;
   var toggleState = false;
   if (fromRawKeyset != toRawKeyset) {
     // Deal with the switch logic to/from English within the compact layout.
     if (fromRawKeyset.indexOf('en.compact') *
         toRawKeyset.indexOf('en.compact') < 0) { // Switches between non-en/en.
       toggle = true;
       toggleState = toRawKeyset.indexOf('en.compact') == -1;
-    } else if (goog.array.contains(util.KEYSETS_HAVE_EN_SWTICHER,
-                   toRawKeyset) &&
-               fromRawKeyset.indexOf(toRawKeyset) == 0 &&
-               fromRawKeyset.indexOf('.compact') > 0 ||
-               fromRawKeyset && toRawKeyset.indexOf(fromRawKeyset) == 0 &&
-               toRawKeyset.indexOf('.compact') > 0) {
+    } else if (fromRawKeyset.indexOf(toRawKeyset) == 0 &&
+        fromRawKeyset.indexOf('.compact') > 0 &&
+        goog.array.contains(util.KEYSETS_HAVE_EN_SWTICHER, toRawKeyset) ||
+        fromRawKeyset && toRawKeyset.indexOf(fromRawKeyset) == 0 &&
+        toRawKeyset.indexOf('.compact') > 0) {
       // Switch between full/compact layouts, reset the default button and
       // language.
       toggle = true;
       toggleState = true;
     }
   }
   if (toggle) {
     this.adapter_.toggleLanguageState(toggleState);
     this.model_.stateManager.isEnMode = !toggleState;
     this.container_.currentKeysetView.update();
@@ skipping 47 matching lines @@
         toKeyset = this.currentKeyset_.replace('compact', 'en.compact');
       }
     }
     if (toKeyset) {
       this.resetAll_();
       this.switchToKeyset(toKeyset);
     }
   }
 };
 });  // goog.scope