Merge remote branch 'cros/upstream' into tempbranch3

frontend/client/src/autotest/common/ui/MultiListSelectPresenter.java

 package autotest.common.ui;
 
 import com.google.gwt.event.dom.client.ChangeEvent;
 import com.google.gwt.event.dom.client.ChangeHandler;
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
 import com.google.gwt.event.dom.client.DoubleClickEvent;
 import com.google.gwt.event.dom.client.DoubleClickHandler;
 import com.google.gwt.event.dom.client.HasClickHandlers;
 import com.google.gwt.event.shared.GwtEvent;
@@ skipping 14 matching lines @@
         public HasClickHandlers getRemoveButton();
         public HasClickHandlers getRemoveAllButton();
         public HasClickHandlers getMoveUpButton();
         public HasClickHandlers getMoveDownButton();
         public SimplifiedList getAvailableList();
         public SimplifiedList getSelectedList();
         // ListBoxes don't support DoubleClickEvents themselves, so the display needs to handle them
         public HandlerRegistration addDoubleClickHandler(DoubleClickHandler handler);
     }
 
-    /* Optional additional display allowing toggle between a simple ListBox and a 
-     * DoubleListSelector 
+    /* Optional additional display allowing toggle between a simple ListBox and a
+     * DoubleListSelector
      */
     public interface ToggleDisplay {
         public SimplifiedList getSingleSelector();
         public ToggleControl getToggleMultipleLink();
         public void setDoubleListVisible(boolean doubleListVisible);
     }
 
     public interface GeneratorHandler {
         /**
          * The given generated Item was just deselected; handle any necessary cleanup.
@@ skipping 39 matching lines @@
 
         @Override
         public int hashCode() {
             return name.hashCode();
         }
 
         @Override
         public String toString() {
             return "Item<" + name + ", " + value + ">";
         }
-        
+
         private boolean isSelected() {
             if (isGeneratedItem) {
                 return true;
             }
             return selected;
         }
-        
+
         private void setSelected(boolean selected) {
             assert !isGeneratedItem;
             this.selected = selected;
         }
     }
 
     /**
      * Null object to support displays that don't do toggling.
      */
     private static class NullToggleDisplay implements ToggleDisplay {
@@ skipping 17 matching lines @@
 
                 @Override
                 public void selectByName(String name) {
                     return;
                 }
 
                 @Override
                 public HandlerRegistration addChangeHandler(ChangeHandler handler) {
                     throw new UnsupportedOperationException();
                 }
+
+                @Override
+                public void setEnabled(boolean enabled) {
+                    throw new UnsupportedOperationException();
+                }
             };
         }
 
         @Override
         public ToggleControl getToggleMultipleLink() {
             return new ToggleControl() {
                 @Override
                 public HandlerRegistration addClickHandler(ClickHandler handler) {
                     throw new UnsupportedOperationException();
                 }
@@ skipping 47 matching lines @@
         this.toggleDisplay = toggleDisplay;
         toggleDisplay.getSingleSelector().addChangeHandler(this);
         toggleDisplay.getToggleMultipleLink().addClickHandler(this);
         toggleDisplay.getToggleMultipleLink().setActive(false);
     }
 
     private boolean verifyConsistency() {
         // check consistency of selectedItems
         for (Item item : items) {
             if (item.isSelected() && !selectedItems.contains(item)) {
-                throw new RuntimeException("selectedItems is inconsistent, missing: " 
+                throw new RuntimeException("selectedItems is inconsistent, missing: "
                                            + item.toString());
             }
         }
         return true;
     }
 
     public void addItem(Item item) {
         if (item.isGeneratedItem && isItemPresent(item)) {
             return;
         }
         items.add(item);
         Collections.sort(items);
         if (item.isSelected()) {
             selectedItems.add(item);
         }
         assert verifyConsistency();
         refresh();
     }
 
     private boolean isItemPresent(Item item) {
         return Collections.binarySearch(items, item) >= 0;
     }
-    
+
     private void removeItem(Item item) {
         items.remove(item);
         if (item.isSelected()) {
             selectedItems.remove(item);
         }
         assert verifyConsistency();
         refresh();
     }
 
     public void clearItems() {
@@ skipping 45 matching lines @@
             }
             refreshSingleSelector();
         }
     }
 
     private void selectItem(Item item) {
         item.setSelected(true);
         selectedItems.add(item);
         assert verifyConsistency();
     }
-    
+
     public void selectItemByName(String name) {
         selectItem(getItemByName(name));
         refresh();
     }
 
     /**
      * Set the set of selected items by specifying item names.  All names must exist in the set of
      * header fields.
      */
     public void setSelectedItemsByName(List<String> names) {
@@ skipping 11 matching lines @@
             }
         }
 
         if (selectedItems.size() < 2) {
             switchToSingle();
         }
         refresh();
     }
 
     /**
-     * Set the set of selected items, silently dropping any that don't exist in the header field 
+     * Set the set of selected items, silently dropping any that don't exist in the header field
      * list.
      */
     public void restoreSelectedItems(List<Item> items) {
         List<String> currentItems = new ArrayList<String>();
         for (Item item : items) {
             if (hasItemName(item.name)) {
                 currentItems.add(item.name);
             }
         }
         setSelectedItemsByName(currentItems);
@@ skipping 42 matching lines @@
     }
 
     private Item findItem(String name) {
         for (Item item : items) {
             if (item.name.equals(name)) {
                 return item;
             }
         }
         return null;
     }
-    
+
     public boolean hasItemName(String name) {
         return findItem(name) != null;
     }
 
     @Override
     public void onClick(ClickEvent event) {
-        boolean isItemSelectedOnLeft = (display.getAvailableList().getSelectedName() != null);
-        boolean isItemSelectedOnRight = (display.getSelectedList().getSelectedName() != null);
+        boolean isItemSelectedOnLeft = display.getAvailableList().getSelectedName() != null;
+        boolean isItemSelectedOnRight = display.getSelectedList().getSelectedName() != null;
         Object source = event.getSource();
         if (source == display.getAddAllButton()) {
             addAll();
         } else if (source == display.getAddButton() && isItemSelectedOnLeft) {
             doSelect();
         } else if (source == display.getRemoveButton() && isItemSelectedOnRight) {
             doDeselect();
         } else if (source == display.getRemoveAllButton()) {
             deselectAll();
         } else if ((source == display.getMoveUpButton() || source == display.getMoveDownButton())
                    && isItemSelectedOnRight) {
             reorderItem(source == display.getMoveUpButton());
             return; // don't refresh again or we'll mess up the user's selection
         } else if (source == toggleDisplay.getToggleMultipleLink()) {
             if (toggleDisplay.getToggleMultipleLink().isActive()) {
                 switchToMultiple();
             } else {
                 switchToSingle();
             }
         } else {
             throw new RuntimeException("Unexpected ClickEvent from " + event.getSource());
         }
-        
+
         refresh();
     }
 
     @Override
     public void onDoubleClick(DoubleClickEvent event) {
         Object source = event.getSource();
         if (source == display.getAvailableList()) {
             doSelect();
         } else if (source == display.getSelectedList()) {
             doDeselect();
         } else {
             // ignore double-clicks on other widgets
             return;
         }
-        
+
         refresh();
     }
 
     @Override
     public void onChange(ChangeEvent event) {
         assert toggleDisplay != null;
         SimplifiedList selector = toggleDisplay.getSingleSelector();
         assert event.getSource() == selector;
         // events should only come from the single selector when it's active
         assert !toggleDisplay.getToggleMultipleLink().isActive();
 
         for (Item item : getItemsCopy()) {
             if (item.isSelected()) {
                 deselectItem(item);
             } else if (item.name.equals(selector.getSelectedName())) {
                 selectItem(item);
             }
         }
-        
+
         refresh();
     }
 
     /**
      * Selecting or deselecting items can add or remove items (due to generators), so sometimes we
      * need to iterate over a copy.
      */
     private Iterable<Item> getItemsCopy() {
         return new ArrayList<Item>(items);
     }
@@ skipping 26 matching lines @@
         Item item = getItemByName(display.getSelectedList().getSelectedName());
         int positionDelta = moveUp ? -1 : 1;
         int newPosition = selectedItems.indexOf(item) + positionDelta;
         newPosition = Math.max(0, Math.min(selectedItems.size() - 1, newPosition));
         selectedItems.remove(item);
         selectedItems.add(newPosition, item);
         refresh();
         display.getSelectedList().selectByName(item.name);
     }
 }