[Checkstyle] Fix misc style issues in Java files.

components/cronet/android/java/src/org/chromium/net/ChromiumUrlRequest.java

 // Copyright 2014 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.util.Log;
 
 import org.apache.http.conn.ConnectTimeoutException;
 import org.chromium.base.CalledByNative;
@@ skipping 165 matching lines @@
                 }
                 return new UnknownHostException("Unknown host: " + host);
             default:
                 throw new IllegalStateException(
                         "Unrecognized error code: " + errorCode);
         }
     }
 
     @Override
     public ByteBuffer getByteBuffer() {
-        return ((ChunkedWritableByteChannel)getSink()).getByteBuffer();
+        return ((ChunkedWritableByteChannel) getSink()).getByteBuffer();
     }
 
     @Override
     public byte[] getResponseAsBytes() {
-        return ((ChunkedWritableByteChannel)getSink()).getBytes();
+        return ((ChunkedWritableByteChannel) getSink()).getBytes();
     }
 
     /**
      * Adds a request header. Must be done before request has started.
      */
     public void addHeader(String header, String value) {
         synchronized (mLock) {
             validateNotStarted();
             if (mAdditionalHeaders == null) {
                 mAdditionalHeaders = new HashMap<String, String>();
             }
             mAdditionalHeaders.put(header, value);
         }
     }
 
     /**
      * Sets data to upload as part of a POST or PUT request.
      *
      * @param contentType MIME type of the upload content or null if this is not
      *            an upload.
      * @param data The content that needs to be uploaded.
      */
+    @Override
     public void setUploadData(String contentType, byte[] data) {
         synchronized (mLock) {
             validateNotStarted();
             validateContentType(contentType);
             mUploadContentType = contentType;
             mUploadData = data;
             mUploadChannel = null;
             mChunkedUpload = false;
         }
     }
 
     /**
      * Sets a readable byte channel to upload as part of a POST or PUT request.
      *
      * @param contentType MIME type of the upload content or null if this is not
      *            an upload request.
      * @param channel The channel to read to read upload data from if this is an
      *            upload request.
      * @param contentLength The length of data to upload.
      */
+    @Override
     public void setUploadChannel(String contentType,
             ReadableByteChannel channel, long contentLength) {
         synchronized (mLock) {
             validateNotStarted();
             validateContentType(contentType);
             mUploadContentType = contentType;
             mUploadChannel = channel;
             mUploadContentLength = contentLength;
             mUploadData = null;
             mChunkedUpload = false;
@@ skipping 54 matching lines @@
     @Override
     public void setHttpMethod(String method) {
         validateNotStarted();
         mMethod = method;
     }
 
     public WritableByteChannel getSink() {
         return mSink;
     }
 
+    @Override
     public void start() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             validateNotStarted();
             validateNotRecycled();
 
             mStarted = true;
@@ skipping 34 matching lines @@
                                        mUploadContentLength);
             } else if (mChunkedUpload) {
                 nativeEnableChunkedUpload(mUrlRequestAdapter,
                                           mUploadContentType);
             }
 
             nativeStart(mUrlRequestAdapter);
           }
     }
 
+    @Override
     public void cancel() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             mCanceled = true;
 
             if (!mRecycled) {
                 nativeCancel(mUrlRequestAdapter);
             }
         }
     }
 
+    @Override
     public boolean isCanceled() {
         synchronized (mLock) {
             return mCanceled;
         }
     }
 
     public boolean isRecycled() {
         synchronized (mLock) {
             return mRecycled;
         }
     }
 
     @Override
     public String getNegotiatedProtocol() {
         validateNotRecycled();
         validateHeadersAvailable();
         return nativeGetNegotiatedProtocol(mUrlRequestAdapter);
     }
 
+    @Override
     public String getContentType() {
         return mContentType;
     }
 
+    @Override
     public String getHeader(String name) {
         validateNotRecycled();
         validateHeadersAvailable();
         return nativeGetHeader(mUrlRequestAdapter, name);
     }
 
     // All response headers.
+    @Override
     public Map<String, List<String>> getAllHeaders() {
         validateNotRecycled();
         validateHeadersAvailable();
         ResponseHeadersMap result = new ResponseHeadersMap();
         nativeGetAllHeaders(mUrlRequestAdapter, result);
         return result;
     }
 
+    @Override
     public String getUrl() {
         return mUrl;
     }
 
     private static int convertRequestPriority(int priority) {
         switch (priority) {
             case HttpUrlRequest.REQUEST_PRIORITY_IDLE:
                 return ChromiumUrlRequestPriority.IDLE;
             case HttpUrlRequest.REQUEST_PRIORITY_LOWEST:
                 return ChromiumUrlRequestPriority.LOWEST;
@@ skipping 75 matching lines @@
 
             if (mContentLengthLimit > 0 &&
                     mContentLength > mContentLengthLimit &&
                     mCancelIfContentLengthOverLimit) {
                 onContentLengthOverLimit();
                     return;
             }
 
             if (mBufferFullResponse && mContentLength != -1 &&
                     !mContentLengthOverLimit) {
-                ((ChunkedWritableByteChannel)getSink()).setCapacity(
-                        (int)mContentLength);
+                ((ChunkedWritableByteChannel) getSink()).setCapacity(
+                        (int) mContentLength);
             }
 
             if (mOffset != 0) {
                 // The server may ignore the request for a byte range, in which
                 // case status code will be 200, instead of 206. Note that we
                 // cannot call getHttpStatusCode as it rewrites 206 into 200.
                 if (nativeGetHttpStatusCode(mUrlRequestAdapter) == 200) {
                     // TODO(mef): Revisit this logic.
                     if (mContentLength != -1) {
                         mContentLength -= mOffset;
@@ skipping 23 matching lines @@
                 return;
             }
 
             int size = buffer.remaining();
             mSize += size;
             if (mSkippingToOffset) {
                 if (mSize <= mOffset) {
                     return;
                 } else {
                     mSkippingToOffset = false;
-                    buffer.position((int)(mOffset - (mSize - size)));
+                    buffer.position((int) (mOffset - (mSize - size)));
                 }
             }
 
             boolean contentLengthOverLimit =
                     (mContentLengthLimit != 0 && mSize > mContentLengthLimit);
             if (contentLengthOverLimit) {
-                buffer.limit(size - (int)(mSize - mContentLengthLimit));
+                buffer.limit(size - (int) (mSize - mContentLengthLimit));
             }
 
             while (buffer.hasRemaining()) {
                 mSink.write(buffer);
             }
             if (contentLengthOverLimit) {
                 onContentLengthOverLimit();
             }
         } catch (Exception e) {
             onCalledByNativeException(e);
@@ skipping 118 matching lines @@
 
     private native void nativeGetAllHeaders(long urlRequestAdapter,
             ResponseHeadersMap headers);
 
     private native String nativeGetNegotiatedProtocol(long urlRequestAdapter);
 
     // Explicit class to work around JNI-generator generics confusion.
     private class ResponseHeadersMap extends HashMap<String, List<String>> {
     }
 }