[Cronet] Remove unused ping and windowUpdate methods

components/cronet/android/api/src/org/chromium/net/BidirectionalStream.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.net;
 
 import android.annotation.SuppressLint;
 import android.support.annotation.IntDef;
 
 import java.lang.annotation.Retention;
@@ skipping 304 matching lines @@
          * Default implementation takes no action.
          *
          * @param stream the stream that was canceled
          * @param info the response information. May be {@code null} if no response was
          *     received.
          */
         public void onCanceled(BidirectionalStream stream, UrlResponseInfo info) {}
     }
 
     /**
-     * A callback that is invoked when the acknowledgement to a {@link #ping ping()} is received.
-     * Exactly one of the two methods will be invoked per each call to {@link #ping ping()}.
-     */
-    public abstract static class PingCallback {
-        /**
-         * Invoked when a ping is acknowledged. The given argument is the round-trip time of the
-         * ping, in microseconds.
-         *
-         * @param roundTripTimeMicros the round-trip duration between the ping being sent and the
-         *     acknowledgement received
-         */
-        public abstract void pingAcknowledged(long roundTripTimeMicros);
-
-        /**
-         * Invoked when a ping fails. The given argument is the cause of the failure.
-         *
-         * @param cause the cause of the ping failure
-         */
-        public abstract void pingFailed(CronetException cause);
-    }
-
-    /**
      * Starts the stream, all callbacks go to the {@code callback} argument passed to {@link
      * BidirectionalStream.Builder}'s constructor. Should only be called once.
      */
     public abstract void start();
 
     /**
      * Reads data from the stream into the provided buffer.
      * Can only be called at most once in response to each invocation of the
      * {@link Callback#onStreamReady onStreamReady()}/
      * {@link Callback#onResponseHeadersReceived onResponseHeadersReceived()} and {@link
@@ skipping 43 matching lines @@
 
     /**
      * Flushes pending writes. This method should not be invoked before {@link
      * Callback#onStreamReady onStreamReady()}. For previously delayed {@link
      * #write write()}s, a corresponding {@link Callback#onWriteCompleted onWriteCompleted()}
      * will be invoked when the buffer is sent.
      */
     public abstract void flush();
 
     /**
-     * Pings remote end-point. {@code callback} methods will be invoked on {@code executor}.
-     *
-     * @param callback the callback that will be invoked when ping succeeds or fails
-     * @param executor the executor on which the callback will be invoked
-     */
-    // TODO(mef): May be last thing to be implemented on Android.
-    public abstract void ping(PingCallback callback, Executor executor);
-
-    /**
-     * Updates stream flow control window.
-     *
-     * @param windowSizeIncrement the value in bytes to increment window by. May be negative.
-     */
-    // TODO(mef): Understand the needs and semantics of this method.
-    public abstract void windowUpdate(int windowSizeIncrement);
-
-    /**
      * Cancels the stream. Can be called at any time after {@link #start}.
      * {@link Callback#onCanceled onCanceled()} will be invoked when cancelation
      * is complete and no further callback methods will be invoked. If the
      * stream has completed or has not started, calling {@code cancel()} has no
      * effect and {@code onCanceled()} will not be invoked. If the
      * {@link Executor} passed in during {@code BidirectionalStream} construction runs
      * tasks on a single thread, and {@code cancel()} is called on that thread,
      * no listener methods (besides {@code onCanceled()}) will be invoked after
      * {@code cancel()} is called. Otherwise, at most one callback method may be
      * invoked after {@code cancel()} has completed.
      */
     public abstract void cancel();
 
     /**
      * Returns {@code true} if the stream was successfully started and is now
      * done (succeeded, canceled, or failed).
      *
      * @return {@code true} if the stream was successfully started and is now
      *         done (completed, canceled, or failed), otherwise returns {@code false}
      *         to indicate stream is not yet started or is in progress.
      */
     public abstract boolean isDone();
 }