Fix list focus after tab key in chrome://settings/autofillEditAddress page.

chrome/browser/resources/options/inline_editable_list.js

 // Copyright (c) 2012 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.
 
 cr.define('options', function() {
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var DeletableItemList = options.DeletableItemList;
 
   /**
    * Creates a new list item with support for inline editing.
@@ skipping 67 matching lines @@
       DeletableItem.prototype.decorate.call(this);
 
       this.editFields_ = [];
       this.addEventListener('mousedown', this.handleMouseDown_);
       this.addEventListener('keydown', this.handleKeyDown_);
       this.addEventListener('focusin', this.handleFocusIn_);
     },
 
     /** @override */
     selectionChanged: function() {
-      this.updateEditState();
+      if (this.parentNode.ignoreChangeEventsCount_ == 0)

[bondd, 2015/01/22 20:23:58]

If you prefer, I could make an accessor
getIgnoreChangeEvents_() {
  return this.ignoreChangeEventsCount_ > 0;
}
Seems fine either way to me.

+        this.updateEditState();
     },
 
     /**
      * Called when this element gains or loses 'lead' status. Updates editing
      * mode accordingly.
      */
     updateLeadState: function() {
       // Add focusability before call to updateEditState.
       if (this.lead) {
         this.setEditableValuesFocusable(true);
@@ skipping 472 matching lines @@
   /**
    * @constructor
    * @extends {options.DeletableItemList}
    */
   var InlineEditableItemList = cr.ui.define('list');
 
   InlineEditableItemList.prototype = {
     __proto__: DeletableItemList.prototype,
 
     /**
+     * List change events are ignored if ignoreChangeEventsCount_ > 0.
+     * Used to modify the list without processing selection change and lead
+     * change events.
+     * @type {number}
+     * @private
+     */
+    ignoreChangeEventsCount_: 0,
+
+    /**
      * Focuses the input element of the placeholder if true.
      * @type {boolean}
      * @private
      */
     needsToFocusPlaceholder_: false,
 
     /** @override */
     decorate: function() {
       DeletableItemList.prototype.decorate.call(this);
       this.setAttribute('inlineeditable', '');
@@ skipping 28 matching lines @@
           leadItem.editing = false;
           // Remove focusability after making other changes.
           if (!leadItem.isPlaceholder)
             leadItem.setEditableValuesFocusable(false);
         }
       }
     },
 
     /** @override */
     handleLeadChange: function(e) {
+      if (this.ignoreChangeEventsCount_ > 0)
+        return;
+
       DeletableItemList.prototype.handleLeadChange.call(this, e);
 
       var focusedColumnIndex = -1;
       if (e.oldValue != -1) {
         var element = this.getListItemByIndex(e.oldValue);
         if (element) {
           focusedColumnIndex = element.focusedColumnIndex;
           element.updateLeadState();
         }
       }
@@ skipping 19 matching lines @@
         if (item) {
           item.setStaticValuesFocusable(true);
           item.setCloseButtonFocusable(true);
           if (item.isPlaceholder)
             item.setEditableValuesFocusable(true);
         }
       }
     },
 
     /**
+     * Execute |callback| with list change events disabled. Selection change and
+     * lead change events will not be processed.
+     * @param {!Function} callback The function to execute.
+     * @protected
+     */
+    ignoreChangeEvents: function(callback) {
+      this.ignoreChangeEventsCount_++;

[Dan Beam, 2015/01/23 22:46:14]

leaving as boolean and doing:

  assert(!this.ignoreChangeEvents_);

is easier than a counter, imo (if there's no nesting callers as of now)

[bondd, 2015/01/29 19:01:02]

Done.

+      callback();
+      this.ignoreChangeEventsCount_--;
+    },
+
+    /**
+     * Set the selected index without changing the focused element on the page.
+     * Used to change the selected index when the list doesn't have focus (and
+     * doesn't want to take focus).
+     * @param {number} index The index to select.
+     */
+    selectIndexWithoutFocusing: function(index) {
+      // Remove focusability from old item.
+      var oldItem = this.getListItemByIndex(this.selectionModel.leadIndex) ||
+                    this.getInitialFocusableItem();
+      if (oldItem) {
+        oldItem.setEditableValuesFocusable(false);
+        oldItem.setStaticValuesFocusable(false);
+        oldItem.setCloseButtonFocusable(false);
+        oldItem.lead = false;
+      }
+
+      // Select the new item.
+      this.ignoreChangeEvents(function() {
+        this.selectionModel.selectedIndex = index;
+      }.bind(this));
+
+      // Add focusability to new item.
+      var newItem = this.getListItemByIndex(index);
+      if (newItem) {
+        if (newItem.isPlaceholder)
+          newItem.setEditableValuesFocusable(true);
+        else
+          newItem.setStaticValuesFocusable(true);
+
+        newItem.setCloseButtonFocusable(true);
+        newItem.lead = true;
+      }
+    },
+
+    /**
      * Focus the placeholder's first input field.
      * Should only be called immediately after the list has been repopulated.
      */
     focusPlaceholder: function() {
       // Remove focusability from initial item.
       var item = this.getInitialFocusableItem();
       if (item) {
         item.setStaticValuesFocusable(false);
         item.setCloseButtonFocusable(false);
       }
@@ skipping 29 matching lines @@
           this.getListItemByIndex(0));
     },
   };
 
   // Export
   return {
     InlineEditableItem: InlineEditableItem,
     InlineEditableItemList: InlineEditableItemList,
   };
 });