fix spelling in core libraries

sdk/lib/async/stream.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.
 
 part of dart.async;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 872 matching lines @@
       onError: future._completeError,
       onDone: () {
         future._complete(result);
       },
       cancelOnError: true);
     return future;
   }
 
   /**
    * Discards all data on the stream, but signals when it's done or an error
-   * occured.
+   * occurred.
    *
    * When subscribing using [drain], cancelOnError will be true. This means
    * that the future will complete with the first error on the stream and then
    * cancel the subscription.
    *
    * In case of a `done` event the future completes with the given
    * [futureValue].
    */
   Future<E> drain<E>([E futureValue])
       => listen(null, cancelOnError: true).asFuture<E>(futureValue);
@@ skipping 712 matching lines @@
    * This allows the stream sink to complete any remaining work and release
    * resources that are no longer needed
    *
    * Returns a future which is completed when the stream sink has shut down.
    * If cleaning up can fail, the error may be reported in the returned future,
    * otherwise it completes with `null`.
    *
    * Returns the same future as [done].
    *
    * The stream sink may close before the [close] method is called, either due
-   * to an error or because it is itself provding events to someone who has
+   * to an error or because it is itself providing events to someone who has
    * stopped listening. In that case, the [done] future is completed first,
    * and the `close` method will return the `done` future when called.
    *
    * Unifies [StreamConsumer.close] and [EventSink.close] which both mark their
    * object as not expecting any further events.
    */
   Future close();
 
   /**
    * Return a future which is completed when the [StreamSink] is finished.
@@ skipping 190 matching lines @@
 class _ControllerEventSinkWrapper<T> implements EventSink<T> {
   EventSink _sink;
   _ControllerEventSinkWrapper(this._sink);
 
   void add(T data) { _sink.add(data); }
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
   void close() { _sink.close(); }
 }