Update the doc comment format.

lib/typed_buffers.dart

 // Copyright (c) 2013, 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.
 
-/**
- * Growable typed-data lists.
- *
- * These lists works just as a typed-data list, except that they are growable.
- * They use an underlying buffer, and when that buffer becomes too small, it
- * is replaced by a new buffer.
- *
- * That means that using the [TypedDataView.buffer] getter is not guaranteed
- * to return the same result each time it is used, and that the buffer may
- * be larger than what the list is using.
- */
+/// Growable typed-data lists.
+///
+/// These lists works just as a typed-data list, except that they are growable.
+/// They use an underlying buffer, and when that buffer becomes too small, it
+/// is replaced by a new buffer.
+///
+/// That means that using the [TypedDataView.buffer] getter is not guaranteed
+/// to return the same result each time it is used, and that the buffer may
+/// be larger than what the list is using.
 library dart.pkg.typed_data.typed_buffers;
 
 import "dart:collection" show ListBase;
 import "dart:typed_data";
 
 abstract class _TypedDataBuffer<E> extends ListBase<E> {
   static const int INITIAL_LENGTH = 8;
 
   /// This is a Uint8List for Uint8Buffer. It's both a List<E> and a TypedData,
   /// which we don't have a type for here.
@@ skipping 164 matching lines @@
   /// Ensures that [_buffer] is at least [requiredCapacity] long,
   ///
   /// Grows the buffer if necessary, preserving existing data.
   void _ensureCapacity(int requiredCapacity) {
     if (requiredCapacity <= _buffer.length) return;
     var newBuffer = _createBiggerBuffer(requiredCapacity);
     newBuffer.setRange(0, _length, _buffer);
     _buffer = newBuffer;
   }
 
-  /**
-   * Create a bigger buffer.
-   *
-   * This method determines how much bigger a bigger buffer should
-   * be. If [requiredCapacity] is not null, it will be at least that
-   * size. It will always have at least have double the capacity of
-   * the current buffer.
-   */
+  /// Create a bigger buffer.
+  ///
+  /// This method determines how much bigger a bigger buffer should
+  /// be. If [requiredCapacity] is not null, it will be at least that
+  /// size. It will always have at least have double the capacity of
+  /// the current buffer.
   List<E> _createBiggerBuffer(int requiredCapacity) {
     int newLength = _buffer.length * 2;
     if (requiredCapacity != null && newLength < requiredCapacity) {
       newLength = requiredCapacity;
     } else if (newLength < INITIAL_LENGTH) {
       newLength = INITIAL_LENGTH;
     }
     return _createBuffer(newLength);
   }
 
@@ skipping 16 matching lines @@
   }
 
   // TypedData.
 
   int get elementSizeInBytes => _buffer.elementSizeInBytes;
 
   int get lengthInBytes => _length * _buffer.elementSizeInBytes;
 
   int get offsetInBytes => _buffer.offsetInBytes;
 
-  /**
-    * Returns the underlying [ByteBuffer].
-    *
-    * The returned buffer may be replaced by operations that change the [length]
-    * of this list.
-    *
-    * The buffer may be larger than [lengthInBytes] bytes, but never smaller.
-    */
+  /// Returns the underlying [ByteBuffer].
+  ///
+  /// The returned buffer may be replaced by operations that change the [length]
+  /// of this list.
+  ///
+  /// The buffer may be larger than [lengthInBytes] bytes, but never smaller.
   ByteBuffer get buffer => _buffer.buffer;
 
   // Specialization for the specific type.
 
   // Return zero for integers, 0.0 for floats, etc.
   // Used to fill buffer when changing length.
   E get _defaultValue;
 
   // Create a new typed list to use as buffer.
   List<E> _createBuffer(int size);
@@ skipping 74 matching lines @@
   Int32x4 get _defaultValue => _zero;
   Int32x4List _createBuffer(int size) => new Int32x4List(size);
 }
 
 class Float32x4Buffer extends _TypedDataBuffer<Float32x4> {
   Float32x4Buffer([int initialLength = 0])
       : super(new Float32x4List(initialLength));
   Float32x4 get _defaultValue => new Float32x4.zero();
   Float32x4List _createBuffer(int size) => new Float32x4List(size);
 }