docs: function(dump) {
        // Completely skip dumps with undefined size.
        if (!hasSize(dump))
          return;
  
        // We only need to consider owned dumps.
        if (dump.ownedBy.length === 0)
          return;
  
        // Sort the owners in decreasing order of ownership importance and
        // increasing order of not-owning sub-size (in case of equal importance).
        var owners = dump.ownedBy.map(function(ownershipLink) {
          return {
            dump: ownershipLink.source,
            importance: optional(ownershipLink.importance, 0),
            notOwningSubSize: optional(ownershipLink.source.notOwningSubSize_, 0)
          };
        });
        owners.sort(function(a, b) {
          if (a.importance === b.importance)
            return a.notOwningSubSize - b.notOwningSubSize;
          return b.importance - a.importance;
        });
  
        // Loop over the list of owners and distribute the owned dump's not-owned
        // sub-size among them according to their ownership importance and
        // not-owning sub-size.
        var currentImportanceStartPos = 0;
        var alreadyAttributedSubSize = 0;
        while (currentImportanceStartPos < owners.length) {
          var currentImportance = owners[currentImportanceStartPos].importance;
  
          // Find the position of the first owner with lower priority.
          var nextImportanceStartPos = currentImportanceStartPos + 1;
          while (nextImportanceStartPos < owners.length &&
                 owners[nextImportanceStartPos].importance ===
                    currentImportance) {
            nextImportanceStartPos++;
          }
  
          // Visit the owners with the same importance in increasing order of
          // not-owned sub-size, split the owned memory among them appropriately,
          // and calculate their owning coefficients.
          var attributedNotOwningSubSize = 0;
          for (var pos = currentImportanceStartPos; pos < nextImportanceStartPos;
               pos++) {
            var owner = owners[pos];
            var notOwningSubSize = owner.notOwningSubSize;
            if (notOwningSubSize > alreadyAttributedSubSize) {
              attributedNotOwningSubSize +=
                  (notOwningSubSize - alreadyAttributedSubSize) /
                  (nextImportanceStartPos - pos);
              alreadyAttributedSubSize = notOwningSubSize;
            }
  
            var owningCoefficient = 0;
            if (notOwningSubSize !== 0)
              owningCoefficient = attributedNotOwningSubSize / notOwningSubSize;
            owner.dump.owningCoefficient_ = owningCoefficient;
          }
  
          currentImportanceStartPos = nextImportanceStartPos;
        }
  
        // Attribute the remainder of the owned dump's not-owned sub-size to
        // the dump itself and calculate its owned coefficient.
        var notOwnedSubSize = optional(dump.notOwnedSubSize_, 0);
        var remainderSubSize = notOwnedSubSize - alreadyAttributedSubSize;
        var ownedCoefficient = 0;
        if (notOwnedSubSize !== 0)
          ownedCoefficient = remainderSubSize / notOwnedSubSize;
        dump.ownedCoefficient_ = ownedCoefficient;
      }