Limit canvas height in heap map.

runtime/bin/vmservice/client/lib/src/elements/heap_map.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library heap_map_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'dart:math';
 import 'observatory_element.dart';
@@ skipping 43 matching lines @@
   var _fragmentationCanvas;
   var _fragmentationData;
   var _pageHeight;
   var _classIdToColor = {};
   var _colorToClassId = {};
   var _classIdToName = {};
 
   static final _freeColor = [255, 255, 255, 255];
   static final _pageSeparationColor = [0, 0, 0, 255];
   static const _PAGE_SEPARATION_HEIGHT = 4;
+  // Many browsers will not display a very tall canvas.
+  // TODO(koda): Improve interface for huge heaps.
+  static const _MAX_CANVAS_HEIGHT = 6000;
 
   @observable String status;
   @published ServiceMap fragmentation;
 
   HeapMapElement.created() : super.created() {
   }
 
   void enteredView() {
     super.enteredView();
     _fragmentationCanvas = shadowRoot.querySelector("#fragmentation");
@@ skipping 84 matching lines @@
     if (fragmentation == null || _fragmentationCanvas == null) {
       return;
     }
     _updateClassList(
         fragmentation['class_list'], fragmentation['free_class_id']);
     var pages = fragmentation['pages'];
     var width = _fragmentationCanvas.parent.client.width;
     _pageHeight = _PAGE_SEPARATION_HEIGHT +
         fragmentation['page_size_bytes'] ~/
         fragmentation['unit_size_bytes'] ~/ width;
-    var height = _pageHeight * pages.length;
+    var height = min(_pageHeight * pages.length, _MAX_CANVAS_HEIGHT);
     _fragmentationData =
         _fragmentationCanvas.context2D.createImageData(width, height);
     _fragmentationCanvas.width = _fragmentationData.width;
     _fragmentationCanvas.height = _fragmentationData.height;
     _renderPages(0);
   }
 
   // Renders and draws asynchronously, one page at a time to avoid
   // blocking the UI.
   void _renderPages(int startPage) {
     var pages = fragmentation['pages'];
     status = 'Loaded $startPage of ${pages.length} pages';
-    if (startPage >= pages.length) {
+    var startY = startPage * _pageHeight;
+    var endY = startY + _pageHeight;
+    if (startPage >= pages.length || endY > _fragmentationData.height) {
       return;
     }
-    var startY = startPage * _pageHeight;
     var pixel = new PixelReference(_fragmentationData, new Point(0, startY));
     var objects = pages[startPage]['objects'];
     for (var i = 0; i < objects.length; i += 2) {
       var count = objects[i];
       var classId = objects[i + 1];
       var color = _classIdToColor[classId];
       while (count-- > 0) {
         pixel.color = color;
         pixel = pixel.next();
       }
     }
-    var endY = startY + _pageHeight;
     while (pixel.point.y < endY) {
       pixel.color = _pageSeparationColor;
       pixel = pixel.next();
     }
     _fragmentationCanvas.context2D.putImageData(
         _fragmentationData, 0, 0, 0, startY, _fragmentationData.width, endY);
     // Continue with the next page, asynchronously.
     new Future(() {
       _renderPages(startPage + 1);
     });
@@ skipping 11 matching lines @@
     }).whenComplete(done);
   }
 
   void fragmentationChanged(oldValue) {
     // Async, in case enteredView has not yet run (observed in JS version).
     new Future(() {
       _updateFragmentationData();
     });
   }
 }