Update to google-input-tools version 1.0.5.0

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.array');
 goog.require('goog.async.Delay');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
 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');
 goog.require('i18n.input.chrome.inputview.KeyboardContainer');
 goog.require('i18n.input.chrome.inputview.M17nModel');
 goog.require('i18n.input.chrome.inputview.Model');
 goog.require('i18n.input.chrome.inputview.PerfTracker');
 goog.require('i18n.input.chrome.inputview.ReadyState');
 goog.require('i18n.input.chrome.inputview.Settings');
 goog.require('i18n.input.chrome.inputview.SizeSpec');
 goog.require('i18n.input.chrome.inputview.SoundController');
 goog.require('i18n.input.chrome.inputview.SpecNodeName');
 goog.require('i18n.input.chrome.inputview.StateType');
-goog.require('i18n.input.chrome.inputview.Statistics');
 goog.require('i18n.input.chrome.inputview.SwipeDirection');
 goog.require('i18n.input.chrome.inputview.elements.ElementType');
 goog.require('i18n.input.chrome.inputview.elements.content.Candidate');
 goog.require('i18n.input.chrome.inputview.elements.content.CandidateView');
 goog.require('i18n.input.chrome.inputview.elements.content.ExpandedCandidateView');
 goog.require('i18n.input.chrome.inputview.elements.content.MenuView');
 goog.require('i18n.input.chrome.inputview.events.EventType');
 goog.require('i18n.input.chrome.inputview.events.KeyCodes');
 goog.require('i18n.input.chrome.inputview.handler.PointerHandler');
 goog.require('i18n.input.chrome.inputview.util');
@@ skipping 44 matching lines @@
     passwordLayout, name) {
   /**
    * The model.
    *
    * @type {!i18n.input.chrome.inputview.Model}
    * @private
    */
   this.model_ = new i18n.input.chrome.inputview.Model();
 
   /** @private {!i18n.input.chrome.inputview.PerfTracker} */
-  this.perfTracker_ = new i18n.input.chrome.inputview.PerfTracker();
+  this.perfTracker_ = new i18n.input.chrome.inputview.PerfTracker(
+      PerfTracker.TickName.HTML_LOADED);
 
   /**
    * The layout map.
    *
    * @type {!Object.<string, !Object>}
    * @private
    */
   this.layoutDataMap_ = {};
 
   /**
@@ skipping 25 matching lines @@
    *
    * @type {!i18n.input.chrome.inputview.handler.PointerHandler}
    * @private
    */
   this.pointerHandler_ = new i18n.input.chrome.inputview.handler.
       PointerHandler();
 
   /**
    * The statistics object for recording metrics values.
    *
-   * @type {!i18n.input.chrome.inputview.Statistics}
+   * @type {!i18n.input.chrome.Statistics}
    * @private
    */
-  this.statistics_ = i18n.input.chrome.inputview.Statistics.getInstance();
+  this.statistics_ = i18n.input.chrome.Statistics.getInstance();
 
   /** @private {!i18n.input.chrome.inputview.ReadyState} */
   this.readyState_ = new i18n.input.chrome.inputview.ReadyState();
 
   /** @private {!i18n.input.chrome.inputview.Adapter} */
   this.adapter_ = new i18n.input.chrome.inputview.Adapter(this.readyState_);
 
   /** @private {!i18n.input.chrome.inputview.KeyboardContainer} */
   this.container_ = new i18n.input.chrome.inputview.KeyboardContainer(
       this.adapter_);
   this.container_.render();
 
   /** @private {!i18n.input.chrome.inputview.SoundController} */
   this.soundController_ = new SoundController(false);
 
   /**
    * The context type and keyset mapping group by input method id.
    * key: input method id.
    * value: Object
    *    key: context type string.
    *    value: keyset string.
    *
    * @private {!Object.<string, !Object.<string, string>>}
    */
   this.contextTypeToKeysetMap_ = {};
 
+  /**
+   * The stats map for input view closing.
+   *
+   * @type {!Object.<string, !Array.<number>>}
+   * @private
+   */
+  this.statsForClosing_ = {};
+
+  /**
+   * The last height sent to window.resizeTo to avoid multiple equivalent calls.
+   *
+   * @private {number}
+   */
+  this.lastResizeHeight_ = -1;
+
+  /**
+   * The activate (show) time stamp for statistics.
+   *
+   * @type {Date}
+   * @private
+   */
+  this.showTimeStamp_ = new Date();
+
   this.initialize(keyset, languageCode, passwordLayout, name);
   /**
    * The suggestions.
    * Note: sets a default empty result to avoid null check.
    *
    * @private {!i18n.input.chrome.inputview.CandidatesInfo}
    */
   this.candidatesInfo_ = i18n.input.chrome.inputview.CandidatesInfo.getEmpty();
 
   this.registerEventHandler_();
@@ skipping 238 matching lines @@
   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['supportCompact'])) {
-    settings.supportCompact = e.msg['supportCompact'];
-  }
   if (goog.isDef(e.msg[Name.KEYSET])) {
     this.contextTypeToKeysetMap_[this.currentInputMethod_][
         ContextType.DEFAULT] = 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_.getContextType();
   var isPassword = this.adapter_.isPasswordBox();
   this.switchToKeySet(this.getActiveKeyset_());
 };
 
 
 /**
  * Callback for setting ready.
  *
  * @private
  */
 Controller.prototype.onSettingsReady_ = function() {
   if (this.isSettingReady) {
     return;
   }
 
   this.isSettingReady = true;
   var keysetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
   if (this.adapter_.isA11yMode) {
     keysetMap[ContextType.PASSWORD] = keysetMap[ContextType.DEFAULT] =
         util.getConfigName(keysetMap[ContextType.DEFAULT]);
   } else {
     var preferredKeyset = /** @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';
+  }
   this.maybeCreateViews_();
   this.switchToKeySet(this.getActiveKeyset_());
 };
 
 
 /**
  * Gets the data for spatial module.
  *
  * @param {!content.SoftKey} key .
  * @param {number} x The x-offset of the touch point.
@@ skipping 55 matching lines @@
  *
  * @param {!i18n.input.chrome.inputview.events.PointerEvent} e .
  * @private
  */
 Controller.prototype.onPointerEvent_ = function(e) {
   if ((this.adapter_.isChromeVoxOn || !this.model_.settings.enableLongPress) &&
       e.type == EventType.LONG_PRESS) {
     return;
   }
 
+  if (e.type == EventType.POINTER_UP) {
+    this.stopBackspaceAutoRepeat_();
+  }
+
   if (e.view) {
     this.handlePointerAction_(e.view, e);
   } else {
     var tabbableKeysets = [
       Controller.HANDWRITING_VIEW_CODE_,
       Controller.EMOJI_VIEW_CODE_];
     if (goog.array.contains(tabbableKeysets, this.currentKeyset_)) {
       this.resetAll_();
       this.switchToKeySet(this.container_.currentKeysetView.fromKeyset);
     }
@@ skipping 52 matching lines @@
     case CommandEnum.SWITCH_IME:
       var inputMethodId = opt_arg;
       if (inputMethodId) {
         this.adapter_.switchToInputMethod(inputMethodId);
       }
       break;
 
     case CommandEnum.SWITCH_KEYSET:
       var keyset = opt_arg;
       if (keyset) {
-        this.statistics_.recordSwitch(keyset);
+        this.recordStatsForClosing_(
+            'InputMethod.VirtualKeyboard.LayoutSwitch', 1, 25, 25);
         this.switchToKeySet(keyset);
       }
       break;
     case CommandEnum.OPEN_EMOJI:
       this.switchToKeySet(Controller.EMOJI_VIEW_CODE_);
       break;
 
     case CommandEnum.OPEN_HANDWRITING:
       // TODO: remember handwriting keyset.
       this.switchToKeySet(Controller.HANDWRITING_VIEW_CODE_);
@@ skipping 15 matching lines @@
  * @param {!i18n.input.chrome.inputview.events.PointerEvent} e .
  * @private
  */
 Controller.prototype.handlePointerAction_ = function(view, e) {
   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) {
+        view.setHighlighted(true);
+      }
       if (e.type == EventType.POINTER_UP) {
         this.switchToKeySet(this.container_.currentKeysetView.fromKeyset);
+        this.clearCandidates_();
       }
       return;
     case ElementType.EXPAND_CANDIDATES:
       if (e.type == EventType.POINTER_UP) {
         this.showCandidates_(this.candidatesInfo_.source,
             this.candidatesInfo_.candidates,
             Controller.CandidatesOperation.EXPAND);
       }
       return;
     case ElementType.SHRINK_CANDIDATES:
       if (e.type == EventType.POINTER_UP) {
         this.showCandidates_(this.candidatesInfo_.source,
             this.candidatesInfo_.candidates,
             Controller.CandidatesOperation.SHRINK);
       }
       return;
     case ElementType.CANDIDATE:
       view = /** @type {!Candidate} */ (view);
       if (e.type == EventType.POINTER_UP) {
         if (view.candidateType == CandidateType.CANDIDATE) {
           this.adapter_.selectCandidate(view.candidate);
         } else if (view.candidateType == CandidateType.NUMBER) {
           this.adapter_.commitText(view.candidate[Name.CANDIDATE]);
         }
         this.container_.cleanStroke();
+        this.soundController_.onKeyUp(ElementType.CANDIDATE);
       }
       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) {
         view.setHighlighted(true);
       }
       return;
 
     case ElementType.ALTDATA_VIEW:
@@ skipping 91 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_));
+            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_),
+            this.adapter_.isExperimental);
       } 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;
 
     case ElementType.MODIFIER_KEY:
       key = /** @type {!content.ModifierKey} */ (softKey);
       var isStateEnabled = this.model_.stateManager.hasState(key.toState);
       var isChording = this.model_.stateManager.isChording(key.toState);
       if (e.type == EventType.POINTER_DOWN) {
-        this.changeState_(key.toState, !isStateEnabled, true);
+        this.changeState_(key.toState, !isStateEnabled, true, false);
         this.model_.stateManager.setKeyDown(key.toState, true);
       } else if (e.type == EventType.POINTER_UP || e.type == EventType.
           POINTER_OUT) {
         if (isChording) {
           this.changeState_(key.toState, false, false);
-        } else if (key.toState != StateType.CAPSLOCK &&
-            this.model_.stateManager.isKeyDown(key.toState)) {
+        } else if (key.toState == StateType.CAPSLOCK) {
+          this.changeState_(key.toState, isStateEnabled, true, true);
+        } else if (this.model_.stateManager.isKeyDown(key.toState)) {
           this.changeState_(key.toState, isStateEnabled, false);
         }
         this.model_.stateManager.setKeyDown(key.toState, false);
       } else if (e.type == EventType.DOUBLE_CLICK) {
-        this.changeState_(key.toState, isStateEnabled, true);
+        this.changeState_(key.toState, isStateEnabled, true, true);
       } else if (e.type == EventType.LONG_PRESS) {
         if (!isChording) {
-          this.changeState_(key.toState, true, true);
+          this.changeState_(key.toState, true, true, true);
           this.model_.stateManager.setKeyDown(key.toState, false);
         }
       }
       break;
 
     case ElementType.BACKSPACE_KEY:
       key = /** @type {!content.FunctionalKey} */ (softKey);
       if (e.type == EventType.POINTER_DOWN) {
         this.backspaceTick_();
       } else if (e.type == EventType.POINTER_UP || e.type == EventType.
           POINTER_OUT) {
         this.stopBackspaceAutoRepeat_();
         this.adapter_.sendKeyUpEvent('\u0008', KeyCodes.BACKSPACE);
       }
       break;
 
     case ElementType.TAB_KEY:
       key = /** @type {!content.FunctionalKey} */ (softKey);
       if (e.type == EventType.POINTER_DOWN) {
         this.adapter_.sendKeyDownEvent('\u0009', KeyCodes.TAB);
       } else if (e.type == EventType.POINTER_UP) {
         this.adapter_.sendKeyUpEvent('\u0009', KeyCodes.TAB);
       }
       break;
 
     case ElementType.ENTER_KEY:
       key = /** @type {!content.FunctionalKey} */ (softKey);
-      if (e.type == EventType.POINTER_DOWN) {
-        this.adapter_.sendKeyDownEvent('\u000D', KeyCodes.ENTER);
-      } else if (e.type == EventType.POINTER_UP) {
-        this.adapter_.sendKeyUpEvent('\u000D', KeyCodes.ENTER);
+      if (e.type == EventType.POINTER_UP) {
+        this.adapter_.sendKeyDownAndUpEvent('\u000D', KeyCodes.ENTER);
       }
       break;
 
     case ElementType.ARROW_UP:
       if (e.type == EventType.POINTER_DOWN) {
         this.adapter_.sendKeyDownEvent('', KeyCodes.ARROW_UP);
       } else if (e.type == EventType.POINTER_UP) {
         this.adapter_.sendKeyUpEvent('', KeyCodes.ARROW_UP);
       }
       break;
@@ skipping 38 matching lines @@
             KeyCodes.SPACE);
         this.clearUnstickyState_();
       } else if (e.type == EventType.DOUBLE_CLICK && doubleSpacePeriod) {
         this.adapter_.doubleClickOnSpaceKey();
       }
       break;
 
     case ElementType.SWITCHER_KEY:
       key = /** @type {!content.SwitcherKey} */ (softKey);
       if (e.type == EventType.POINTER_UP) {
-        this.statistics_.recordSwitch(key.toKeyset);
+        this.recordStatsForClosing_(
+            'InputMethod.VirtualKeyboard.LayoutSwitch', 1, 25, 25);
         if (this.isSubKeyset_(key.toKeyset, this.currentKeyset_)) {
           this.model_.stateManager.reset();
           this.container_.update();
           this.updateContextModifierState_();
           this.container_.menuView.hide();
         } else {
           this.resetAll_();
         }
         // Switch to the specific keyboard.
         this.switchToKeySet(key.toKeyset);
         if (key.record) {
           this.model_.settings.savePreference(
               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_));
+            key, goog.i18n.bidi.isRtlLanguage(this.languageCode_),
+            this.adapter_.isExperimental);
       } else if (e.type == EventType.POINTER_UP) {
         this.model_.stateManager.triggerChording();
         this.adapter_.sendKeyDownAndUpEvent(key.getActiveCharacter(), '', 0,
             this.getSpatialData_(key, e.x, e.y));
         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);
+      }
       break;
 
     case ElementType.MENU_KEY:
       key = /** @type {!content.MenuKey} */ (softKey);
       if (e.type == EventType.POINTER_DOWN) {
         var isCompact = this.currentKeyset_.indexOf('compact') != -1;
-        var remappedKeyset = this.getRemappedKeyset_(this.currentKeyset_);
-        var keysetData = this.keysetDataMap_[remappedKeyset];
-        var enableCompact = !this.adapter_.isA11yMode &&
-            !!keysetData[SpecNodeName.HAS_COMPACT_KEYBOARD] &&
-            this.model_.settings.supportCompact;
+        var defaultKeyset = this.contextTypeToKeysetMap_[
+            this.currentInputMethod_][ContextType.DEFAULT];
+        var enableCompact = !this.adapter_.isA11yMode && goog.array.contains(
+            util.KEYSETS_HAVE_COMPACT, defaultKeyset.split(/\./)[0]);
+        if (defaultKeyset == 'zhuyin' && !this.adapter_.isExperimental ||
+            this.languageCode_ == 'ko') {
+          // Hides 'switch to compact' for zhuyin when not in experimental env.
+          enableCompact = false;
+        }
         var self = this;
-        var currentKeyset = this.currentKeyset_;
         var hasHwt = !this.adapter_.isPasswordBox() &&
             !Controller.DISABLE_HWT && goog.object.contains(
-            InputToolCode, this.getHwtInputToolCode_());
+            InputToolCode, this.getHwtInputToolCode_()) &&
+            this.languageCode_ != 'ko';
         var enableSettings = this.shouldEnableSettings() &&
-            window.inputview && inputview.openSettings;
+            !!window.inputview && !!inputview.openSettings;
         this.adapter_.getInputMethods(function(inputMethods) {
-          this.container_.menuView.show(key, currentKeyset, isCompact,
+          this.container_.menuView.show(key, defaultKeyset, isCompact,
               enableCompact, this.currentInputMethod_, inputMethods, hasHwt,
               enableSettings, this.adapter_.isExperimental);
         }.bind(this));
       }
       break;
 
     case ElementType.GLOBE_KEY:
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.clearModifierStates();
         this.adapter_.setModifierState(
@@ skipping 32 matching lines @@
   this.container_.update();
 };
 
 
 /**
  * Stops the auto-repeat for backspace.
  *
  * @private
  */
 Controller.prototype.stopBackspaceAutoRepeat_ = function() {
-  goog.dispose(this.backspaceAutoRepeat_);
-  this.backspaceAutoRepeat_ = null;
-  this.adapter_.sendKeyUpEvent('\u0008', KeyCodes.BACKSPACE);
-  this.backspaceRepeated_ = 0;
+  if (this.backspaceAutoRepeat_) {
+    goog.dispose(this.backspaceAutoRepeat_);
+    this.backspaceAutoRepeat_ = null;
+    this.adapter_.sendKeyUpEvent('\u0008', KeyCodes.BACKSPACE);
+    this.backspaceRepeated_ = 0;
+  }
 };
 
 
 /**
  * The tick for the backspace key.
  *
  * @private
  */
 Controller.prototype.backspaceTick_ = function() {
   if (this.backspaceRepeated_ >= Controller.BACKSPACE_REPEAT_LIMIT_) {
@@ skipping 14 matching lines @@
 };
 
 
 /**
  * Callback for VISIBILITY_CHANGE.
  *
  * @private
  */
 Controller.prototype.onVisibilityChange_ = function() {
   if (!this.adapter_.isVisible) {
+    for (var name in this.statsForClosing_) {
+      var stat = this.statsForClosing_[name];
+      this.statistics_.recordValue(name, stat[0], stat[1], stat[2]);
+    }
+    this.statistics_.recordValue('InputMethod.VirtualKeyboard.Duration',
+        Math.floor((new Date() - this.showTimeStamp_) / 1000), 4096, 50);
+    this.statsForClosing_ = {};
+    this.showTimeStamp_ = new Date();
     this.resetAll_();
   }
 };
 
 
 /**
  * Resets the whole keyboard include clearing candidates,
  * reset modifier state, etc.
  *
  * @private
  */
 Controller.prototype.resetAll_ = function() {
   this.clearCandidates_();
+  this.container_.cleanStroke();
   this.container_.candidateView.hideNumberRow();
   this.model_.stateManager.reset();
   this.container_.update();
   this.updateContextModifierState_();
   this.deadKey_ = '';
   this.resize();
   this.container_.expandedCandidateView.close();
   this.container_.menuView.hide();
 };
 
 
 /**
  * Callback when the context is changed.
  *
  * @private
  */
 Controller.prototype.onContextFocus_ = function() {
   this.resetAll_();
+  this.model_.stateManager.contextType = this.adapter_.getContextType();
   this.switchToKeySet(this.getActiveKeyset_());
 };
 
 
 /**
  * Callback when surrounding text is changed.
  *
  * @param {!i18n.input.chrome.inputview.events.SurroundingTextChangedEvent} e .
  * @private
  */
@@ skipping 14 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
  */
 Controller.prototype.backspaceDown_ = function() {
   if (this.container_.hasStrokesOnCanvas()) {
     this.clearCandidates_();
     this.container_.cleanStroke();
   } else {
     this.adapter_.sendKeyDownEvent('\u0008', KeyCodes.BACKSPACE);
   }
+  this.recordStatsForClosing_(
+      'InputMethod.VirtualKeyboard.BackspaceCount', 1, 4095, 4096);
+  this.statistics_.recordEnum('InputMethod.VirtualKeyboard.BackspaceOnLayout',
+      this.statistics_.getLayoutType(this.currentKeyset_,
+          this.adapter_.isA11yMode),
+      i18n.input.chrome.Statistics.LayoutTypes.MAX);
 };
 
 
 /**
  * Callback for state change.
  *
  * @param {StateType} stateType The state type.
  * @param {boolean} enable True to enable the state.
  * @param {boolean} isSticky True to make the state sticky.
+ * @param {boolean=} opt_isFinalSticky .
  * @private
  */
-Controller.prototype.changeState_ = function(stateType, enable, isSticky) {
+Controller.prototype.changeState_ = function(stateType, enable, isSticky,
+    opt_isFinalSticky) {
   if (stateType == StateType.ALTGR) {
     var code = KeyCodes.ALT_RIGHT;
     if (enable) {
       this.adapter_.sendKeyDownEvent('', code);
     } else {
       this.adapter_.sendKeyUpEvent('', code);
     }
   }
   if (stateType == StateType.SHIFT) {
     this.shiftForAutoCapital_ = false;
   }
   var isEnabledBefore = this.model_.stateManager.hasState(stateType);
   var isStickyBefore = this.model_.stateManager.isSticky(stateType);
   this.model_.stateManager.setState(stateType, enable);
   this.model_.stateManager.setSticky(stateType, isSticky);
-  if (isEnabledBefore != enable || isStickyBefore != isSticky) {
+  var isFinalSticky = goog.isDef(opt_isFinalSticky) ? opt_isFinalSticky :
+      false;
+  var isFinalStikcyBefore = this.model_.stateManager.isFinalSticky(stateType);
+  this.model_.stateManager.setFinalSticky(stateType, isFinalSticky);
+  if (isEnabledBefore != enable || isStickyBefore != isSticky ||
+      isFinalStikcyBefore != isFinalSticky) {
     this.container_.update();
   }
 };
 
 
 /**
  * Updates the modifier state for context.
  *
  * @private
  */
@@ skipping 166 matching lines @@
 Controller.prototype.switchToKeySet = function(keyset) {
   if (!this.isSettingReady) {
     return;
   }
 
   var lastKeysetView = this.container_.currentKeysetView;
   var ret = this.container_.switchToKeyset(this.getRemappedKeyset_(keyset),
       this.title_, this.adapter_.isPasswordBox(), this.adapter_.isA11yMode,
       keyset, this.currentKeyset_, this.languageCode_);
 
-  // Update the keyset of current context type.
-  this.contextTypeToKeysetMap_[this.currentInputMethod_][
-      this.adapter_.getContextType()] = keyset;
+  if (!this.isSubKeyset_(this.currentKeyset_, keyset)) {
+    // If it is the sub keyset switching, don't record it.
+    // Update the keyset of current context type.
+    this.contextTypeToKeysetMap_[this.currentInputMethod_][
+        this.adapter_.getContextType()] = keyset;
+  }
 
   if (ret) {
     this.updateLanguageState_(this.currentKeyset_, keyset);
     // Deactivate the last keyset view instance.
     if (lastKeysetView) {
       lastKeysetView.deactivate(this.currentKeyset_);
     }
     this.currentKeyset_ = keyset;
 
     this.resize(Controller.DEV);
-    this.statistics_.setCurrentLayout(keyset);
+    this.statistics_.recordLayout(keyset, this.adapter_.isA11yMode);
     // Activate the current key set view instance.
     this.container_.currentKeysetView.activate(keyset);
     this.perfTracker_.tick(PerfTracker.TickName.KEYBOARD_SHOWN);
     this.perfTracker_.stop();
   } else {
     this.loadResource_(keyset);
   }
 };
 
 
@@ skipping 61 matching lines @@
         widthPercent = spec.HORIZONTAL;
       }
     } else {
       widthPercent = spec.VERTICAL;
     }
     candidateViewHeight = SizeSpec.NON_A11Y_CANDIDATE_VIEW_HEIGHT;
   }
 
   var viewportSize = goog.dom.getViewportSize();
   if (viewportSize.height != height && !opt_ignoreWindowResize) {
-    window.resizeTo(screen.width, height);
+    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) {
     this.isKeyboardReady = true;
   }
 };
 
@@ skipping 61 matching lines @@
  *
  * @param {string} keyset The keyboard keyset.
  * @param {string} languageCode The language code for this keyboard.
  * @param {string} passwordLayout The layout for password box.
  * @param {string} title The title for this keyboard.
  */
 Controller.prototype.initialize = function(keyset, languageCode, passwordLayout,
     title) {
   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_] = {};
     }
     keySetMap[ContextType.PASSWORD] = passwordLayout;
     keySetMap[ContextType.DEFAULT] = keyset;
 
     this.title_ = title;
@@ skipping 76 matching lines @@
 
 /**
  * Updates the compact pinyin to set the inputcode for english and pinyin.
  *
  * @param {string} fromRawKeyset .
  * @param {string} toRawKeyset .
  * @private
  */
 Controller.prototype.updateLanguageState_ =
     function(fromRawKeyset, toRawKeyset) {
-  if (fromRawKeyset == 'pinyin-zh-CN.en.compact.qwerty' &&
-      toRawKeyset.indexOf('en.compact') == -1) {
-    this.adapter_.toggleLanguageState(true);
-  } else if (fromRawKeyset.indexOf('en.compact') == -1 &&
-      toRawKeyset == 'pinyin-zh-CN.en.compact.qwerty') {
-    this.adapter_.toggleLanguageState(false);
-  } else if (goog.array.contains(
-      i18n.input.chrome.inputview.util.KEYSETS_HAVE_EN_SWTICHER,
-      toRawKeyset)) {
-    this.adapter_.toggleLanguageState(true);
-    this.model_.stateManager.isEnMode = false;
+  var toggle = false;
+  var toggleState = false;
+  // 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 (fromRawKeyset.indexOf(toRawKeyset) == 0 &&
+             fromRawKeyset.indexOf('.compact') > 0 ||
+             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();
   }
 };
+
+
+/**
+ * Records the stats which will be reported when input view is closing.
+ *
+ * @param {string} name The metrics name.
+ * @param {number} count The count value for histogram.
+ * @param {number} max .
+ * @param {number} bucketCount .
+ * @private
+ */
+Controller.prototype.recordStatsForClosing_ = function(
+    name, count, max, bucketCount) {
+  if (!this.statsForClosing_[name]) {
+    this.statsForClosing_[name] = [count, max, bucketCount];
+  } else {
+    this.statsForClosing_[name][0] += count;
+    this.statsForClosing_[name][1] = max;
+    this.statsForClosing_[name][2] = bucketCount;
+  }
+};
 });  // goog.scope