Fix missing entry showing number of cookies in first domain of chrome://settings/cookies

chrome/browser/resources/options2/cookies_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 DeletableItemList = options.DeletableItemList;
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var ArrayDataModel = cr.ui.ArrayDataModel;
   /** @const */ var ListSingleSelectionModel = cr.ui.ListSingleSelectionModel;
 
@@ skipping 579 matching lines @@
     set parent(parent) {
       if (parent == this.parent)
         return;
 
       if (parent instanceof CookieListItem) {
         // If the parent is to be a CookieListItem, then we keep the reference
         // to it by its containing list and list index, rather than directly.
         // This allows the list items to be garbage collected when they scroll
         // out of view (except the expanded item, which we cache). This is
         // transparent except in the setter and getter, where we handle it.
-        this.parent_ = parent.listIndex;
+        if (this.parent_ == undefined || parent.listIndex != -1) {

[Mike Mammarella, 2012/08/14 00:50:56]

I'm not quite sure I understand the first part of this condition. Why not just
"if (parent.listIndex != -1) {" here? Is the idea that if we have no parent
right now, then the fake -1 index CookieListItem is OK, but otherwise we want to
ignore attempting to set it on top of the previous parent?

[battre, 2012/08/17 15:59:05]

This is actually necessary. This way the parent with an invalid index can be
registered once and update the link via the 'listIndexChange' event that we
subscribe to below. If we remove the first condition, no summaries are shown at
all.

+          // Setting the parent is somewhat tricky because the CookieListItem
+          // constructor has side-effects on the |origin| that it wraps. Every
+          // time a CookieListItem is created for an |origin|, it registers
+          // itself as the parent of the |origin|.
+          // The List implementation may create a temporary CookieListItem item
+          // that wraps the |origin| of the very first entry of the CokiesList,
+          // when the List is redrawn the first time. This temporary
+          // CookieListItem is fresh (has listIndex = -1) and is never inserted
+          // into the List. Therefore it gets never updated. This destroys the
+          // chain of parent pointers.
+          // This is the stack trace:
+          //     CookieListItem
+          //     CookiesList.createItem
+          //     List.measureItem
+          //     List.getDefaultItemSize_
+          //     List.getDefaultItemHeight_
+          //     List.getIndexForListOffset_
+          //     List.getItemsInViewPort
+          //     List.redraw
+          //     List.endBatchUpdates
+          //     CookiesList.loadChildren
+          this.parent_ = parent.listIndex;
+        }
         this.list_ = parent.list;
         parent.addEventListener('listIndexChange',
                                 this.parentIndexChanged_.bind(this));
       } else {
         this.parent_ = parent;
       }
 
       if (this.data && this.data.id) {
         if (parent)
           parentLookup[this.data.id] = this;
@@ skipping 283 matching lines @@
       parent.clear();
       this.addByParent_(parent, 0, children);
       parent.endBatchUpdates();
     },
   };
 
   return {
     CookiesList: CookiesList
   };
 });