[Extensions Page] Add a listener on extension list for "hasExtensions" changing

chrome/browser/resources/extensions/extension_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.
 
 <include src="extension_error.js">
 
 ///////////////////////////////////////////////////////////////////////////////
 // ExtensionFocusRow:
 
 /**
@@ skipping 144 matching lines @@
         return -1;
       if (y.location == chrome.developerPrivate.Location.UNPACKED)
         return 1;
       return 0;
     }
     return compareLocation(a, b) ||
            compare(a.name.toLowerCase(), b.name.toLowerCase()) ||
            compare(a.id, b.id);
   }
 
+  /** @interface */
+  function ExtensionListDelegate() {}
+
+  ExtensionListDelegate.prototype = {
+    /**
+     * Called when the number of extensions in the list has changed.
+     */
+    onExtensionCountChanged: assertNotReached,
+  };
+
   /**
    * Creates a new list of extensions.
+   * @param {ExtensionListDelegate} delegate

[Devlin, 2015/04/27 20:02:03]

Strangely, this (and also lines 244 and 250, as well as the references in
extensions.js) is still producing a warning for an "Unknown type
ExtensionListDelegate"... (making it extensions.ExtensionListDelegate didn't
help.  All seems well when running the page.)

Any ideas?

[Dan Beam, 2015/04/27 21:02:27]

this will work:

extensions.ExtensionListDelegate = function() {};
extensions.ExtensionListDelegate.prototype = {...};

pretty huge bummer that our compiler pass doesn't pick up your version, though
:(

[Devlin, 2015/04/27 21:11:54]

Bummer indeed.  Odd that it worked fine when putting it on ExtensionList, minus
the first reference (i.e., there was 1 error, not 5).

Anyway, fixed.

[Devlin, 2015/04/27 22:19:47]

Fixed better, from offline conversation.

    * @constructor
    * @extends {HTMLDivElement}
    */
-  function ExtensionList() {
+  function ExtensionList(delegate) {
     var div = document.createElement('div');
     div.__proto__ = ExtensionList.prototype;
-    div.initialize();
+    div.initialize(delegate);
     return div;
   }
 
   /**
    * @type {Object<string, number>} A map from extension id to last reloaded
    *     timestamp. The timestamp is recorded when the user click the 'Reload'
    *     link. It is used to refresh the icon of an unpacked extension.
    *     This persists between calls to decorate.
    */
   var extensionReloadedTimestamp = {};
@@ skipping 39 matching lines @@
     incognitoAvailable_: false,
 
     /**
      * Whether or not the app info dialog is enabled.
      * @private {boolean}
      */
     enableAppInfoDialog_: false,
 
     /**
      * Initializes the list.
+     * @param {!ExtensionListDelegate} delegate
      */
-    initialize: function() {
+    initialize: function(delegate) {
       /** @private {!Array<ExtensionInfo>} */
       this.extensions_ = [];
 
+      /** @private {!ExtensionListDelegate} */
+      this.delegate_ = delegate;
+
       /**
        * |loadFinished| should be used for testing purposes and will be
        * fulfilled when this list has finished loading the first time.
        * @type {Promise}
        * */
       this.loadFinished = new Promise(function(resolve, reject) {
         /** @private {function(?)} */
         this.resolveLoadFinished_ = resolve;
       }.bind(this));
 
       chrome.developerPrivate.onItemStateChanged.addListener(
           function(eventData) {
         var EventType = chrome.developerPrivate.EventType;
         switch (eventData.event_type) {
           case EventType.VIEW_REGISTERED:
           case EventType.VIEW_UNREGISTERED:
           case EventType.INSTALLED:
           case EventType.LOADED:
           case EventType.UNLOADED:
           case EventType.ERROR_ADDED:
           case EventType.PREFS_CHANGED:
             if (eventData.extensionInfo)
               this.updateExtension_(eventData.extensionInfo);
             break;
           case EventType.UNINSTALLED:
+            var index = this.getIndexOfExtension_(eventData.item_id);
+            this.extensions_.splice(index, 1);
             var childNode = $(eventData.item_id);
             childNode.parentNode.removeChild(childNode);
             break;
           default:
             assertNotReached();
         }
+
+        if (eventData.event_type == EventType.INSTALLED ||
+            eventData.event_type == EventType.UNINSTALLED) {
+          this.delegate_.onExtensionCountChanged();
+        }
       }.bind(this));
     },
 
     /**
      * Updates the extensions on the page.
      * @param {boolean} incognitoAvailable Whether or not incognito is allowed.
      * @param {boolean} enableAppInfoDialog Whether or not the app info dialog
      *     is enabled.
      * @return {Promise} A promise that is resolved once the extensions data is
      *     fully updated.
@@ skipping 48 matching lines @@
       var idToOpenOptions = this.getOptionsQueryParam_();
       if (idToOpenOptions && $(idToOpenOptions))
         this.showEmbeddedExtensionOptions_(idToOpenOptions, true);
     },
 
     /** @return {number} The number of extensions being displayed. */
     getNumExtensions: function() {
       return this.extensions_.length;
     },
 
+    /**
+     * @param {string} id The id of the extension.
+     * @return {number} The index of the extension with the given id.
+     * @private
+     */
+    getIndexOfExtension_: function(id) {
+      for (var i = 0; i < this.extensions_.length; ++i) {
+        if (this.extensions_[i].id == id)
+          return i;
+      }
+      return -1;
+    },
+
     getIdQueryParam_: function() {
       return parseQueryParams(document.location)['id'];
     },
 
     getOptionsQueryParam_: function() {
       return parseQueryParams(document.location)['options'];
     },
 
     /**
      * Creates or updates all extension items from scratch.
@@ skipping 709 matching lines @@
       overlay.setInitialFocus();
     },
 
     /**
      * Updates the node for the extension.
      * @param {!ExtensionInfo} extension The information about the extension to
      *     update.
      * @private
      */
     updateExtension_: function(extension) {
-      var currIndex = -1;
-      for (var i = 0; i < this.extensions_.length; ++i) {
-        if (this.extensions_[i].id == extension.id) {
-          currIndex = i;
-          break;
-        }
-      }
+      var currIndex = this.getIndexOfExtension_(extension.id);
       if (currIndex != -1) {
         // If there is a current version of the extension, update it with the
         // new version.
         this.extensions_[currIndex] = extension;
       } else {
         // If the extension isn't found, push it back and sort. Technically, we
         // could optimize by inserting it at the right location, but since this
         // only happens on extension install, it's not worth it.
         this.extensions_.push(extension);
         this.extensions_.sort(compareExtensions);
       }
 
       var node = /** @type {ExtensionFocusRow} */ ($(extension.id));
       if (node) {
         this.updateNode_(extension, node);
       } else {
         var nextExt = this.extensions_[this.extensions_.indexOf(extension) + 1];
         this.createNode_(extension, nextExt ? $(nextExt.id) : null);
       }
     }
   };
 
   return {
     ExtensionList: ExtensionList
   };
 });