Add links to page that explains The Observable Contract

Author: DavidMGross

src/main/java/rx/Observable.java

@@ -6830,8 +6830,8 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
     }
 
     /**
-     * Forces an Observable's emissions and notifications to be serialized and for it to obey the Rx contract
-     * in other ways.
+     * Forces an Observable's emissions and notifications to be serialized and for it to obey
+     * <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a> in other ways.
      * <p>
      * It is possible for an Observable to invoke its Subscribers' methods asynchronously, perhaps from
      * different threads. This could make such an Observable poorly-behaved, in that it might try to invoke
@@ -7672,7 +7672,9 @@ public void onNext(T t) {
      * error handling, unsubscribe, or execution hooks.
      * <p>
      * Use this only for implementing an {@link Operator} that requires nested subscriptions. For other
-     * purposes, use {@link #subscribe(Subscriber)} which ensures the Rx contract and other functionality.
+     * purposes, use {@link #subscribe(Subscriber)} which ensures
+     * <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a> and other
+     * functionality.
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code unsafeSubscribe} does not operate by default on a particular {@link Scheduler}.</dd>

src/main/java/rx/internal/util/RxRingBuffer.java

@@ -26,8 +26,9 @@
 import rx.internal.util.unsafe.UnsafeAccess;
 
 /**
- * This assumes Spsc or Spmc usage. This means only a single producer calling the on* methods. This is the Rx contract of an Observer.
- * Concurrent invocations of on* methods will not be thread-safe.
+ * This assumes Spsc or Spmc usage. This means only a single producer calling the on* methods. This is the Rx
+ * contract of an Observer (see http://reactivex.io/documentation/contract.html). Concurrent invocations of
+ * on* methods will not be thread-safe.
  */
 public class RxRingBuffer implements Subscription {
 

src/main/java/rx/observables/BlockingObservable.java

@@ -96,7 +96,7 @@ public void forEach(final Action1<? super T> onNext) {
 
         /*
          * Use 'subscribe' instead of 'unsafeSubscribe' for Rx contract behavior
-         * as this is the final subscribe in the chain.
+         * (see http://reactivex.io/documentation/contract.html) as this is the final subscribe in the chain.
          */
         Subscription subscription = o.subscribe(new Subscriber<T>() {
             @Override

src/main/java/rx/observers/SafeSubscriber.java

@@ -26,7 +26,7 @@
 
 /**
  * {@code SafeSubscriber} is a wrapper around {@code Subscriber} that ensures that the {@code Subscriber}
- * complies with the Rx contract.
+ * complies with <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a>.
  * <p>
  * The following is taken from <a href="http://go.microsoft.com/fwlink/?LinkID=205219">the Rx Design Guidelines
  * document</a>:

src/main/java/rx/subjects/SerializedSubject.java

@@ -24,8 +24,8 @@
  * <p>
  * When you use an ordinary {@link Subject} as a {@link Subscriber}, you must take care not to call its
  * {@link Subscriber#onNext} method (or its other {@code on} methods) from multiple threads, as this could lead
- * to non-serialized calls, which violates the Observable contract and creates an ambiguity in the resulting
- * Subject.
+ * to non-serialized calls, which violates <a href="http://reactivex.io/documentation/contract.html">the
+ * Observable contract</a> and creates an ambiguity in the resulting Subject.
  * <p>
  * To protect a {@code Subject} from this danger, you can convert it into a {@code SerializedSubject} with code
  * like the following:

src/main/java/rx/subjects/Subject.java

@@ -40,10 +40,12 @@ protected Subject(OnSubscribe<R> onSubscribe) {
      * <p>
      * When you use an ordinary {@link Subject} as a {@link Subscriber}, you must take care not to call its 
      * {@link Subscriber#onNext} method (or its other {@code on} methods) from multiple threads, as this could 
-     * lead to non-serialized calls, which violates the Observable contract and creates an ambiguity in the resulting Subject.
+     * lead to non-serialized calls, which violates
+     * <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a> and creates an
+     * ambiguity in the resulting Subject.
      * <p>
-     * To protect a {@code Subject} from this danger, you can convert it into a {@code SerializedSubject} with code
-     * like the following:
+     * To protect a {@code Subject} from this danger, you can convert it into a {@code SerializedSubject} with
+     * code like the following:
      * <p><pre>{@code
      * mySafeSubject = myUnsafeSubject.toSerialized();
      * }</pre>