Rename url_request_[context_]peer.* into url_request_[context_]adapter.*

components/cronet/android/java/src/org/chromium/net/UrlRequest.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 org.apache.http.conn.ConnectTimeoutException;
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
@@ skipping 34 matching lines @@
     private volatile boolean mCanceled;
     private volatile boolean mRecycled;
     private volatile boolean mFinished;
     private boolean mHeadersAvailable;
     private String mContentType;
     private long mContentLength;
     private long mUploadContentLength;
     private final ContextLock mLock;
 
     /**
-     * Native peer object, owned by UrlRequest.
+     * Native adapter object, owned by UrlRequest.
      */
-    private long mUrlRequestPeer;
+    private long mUrlRequestAdapter;
 
     /**
      * Constructor.
      *
      * @param requestContext The context.
      * @param url The URL.
      * @param priority Request priority, e.g. {@link #REQUEST_PRIORITY_MEDIUM}.
      * @param headers HTTP headers.
      * @param sink The output channel into which downloaded content will be
      *            written.
      */
     public UrlRequest(UrlRequestContext requestContext, String url,
             int priority, Map<String, String> headers,
             WritableByteChannel sink) {
         if (requestContext == null) {
             throw new NullPointerException("Context is required");
         }
         if (url == null) {
             throw new NullPointerException("URL is required");
         }
         mRequestContext = requestContext;
         mUrl = url;
         mPriority = priority;
         mHeaders = headers;
         mSink = sink;
         mLock = new ContextLock();
-        mUrlRequestPeer = nativeCreateRequestPeer(
-                mRequestContext.getUrlRequestContextPeer(), mUrl, mPriority);
+        mUrlRequestAdapter = nativeCreateRequestAdapter(
+                mRequestContext.getUrlRequestContextAdapter(), mUrl, mPriority);
     }
 
     /**
      * Adds a request header.
      */
     public void addHeader(String header, String value) {
         validateNotStarted();
         if (mAdditionalHeaders == null) {
             mAdditionalHeaders = new HashMap<String, String>();
         }
@@ skipping 33 matching lines @@
             mUploadContentType = contentType;
             mUploadChannel = channel;
             mUploadContentLength = contentLength;
             mUploadData = null;
         }
     }
 
     public void setHttpMethod(String method) {
         validateNotStarted();
         if (!("PUT".equals(method) || "POST".equals(method))) {
-            throw new IllegalArgumentException("Only PUT and POST are allowed.");
+            throw new IllegalArgumentException("Only PUT or POST are allowed.");
         }
         mMethod = method;
     }
 
     public WritableByteChannel getSink() {
         return mSink;
     }
 
     public void start() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             validateNotStarted();
             validateNotRecycled();
 
             mStarted = true;
 
             String method = mMethod;
             if (method == null &&
                     ((mUploadData != null && mUploadData.length > 0) ||
                       mUploadChannel != null)) {
                 // Default to POST if there is data to upload but no method was
                 // specified.
                 method = "POST";
             }
 
             if (method != null) {
-                nativeSetMethod(mUrlRequestPeer, method);
+                nativeSetMethod(mUrlRequestAdapter, method);
             }
 
             if (mHeaders != null && !mHeaders.isEmpty()) {
                 for (Entry<String, String> entry : mHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestPeer, entry.getKey(),
+                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(),
                                     entry.getValue());
               }
             }
 
             if (mAdditionalHeaders != null) {
                 for (Entry<String, String> entry :
                      mAdditionalHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestPeer, entry.getKey(),
+                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(),
                                     entry.getValue());
               }
             }
 
             if (mUploadData != null && mUploadData.length > 0) {
-                nativeSetUploadData(mUrlRequestPeer, mUploadContentType,
+                nativeSetUploadData(mUrlRequestAdapter, mUploadContentType,
                                     mUploadData);
             } else if (mUploadChannel != null) {
-                nativeSetUploadChannel(mUrlRequestPeer, mUploadContentType,
+                nativeSetUploadChannel(mUrlRequestAdapter, mUploadContentType,
                                        mUploadContentLength);
             }
 
-            nativeStart(mUrlRequestPeer);
+            nativeStart(mUrlRequestAdapter);
           }
     }
 
     public void cancel() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             mCanceled = true;
 
             if (!mRecycled) {
-                nativeCancel(mUrlRequestPeer);
+                nativeCancel(mUrlRequestAdapter);
             }
         }
     }
 
     public boolean isCanceled() {
         synchronized (mLock) {
             return mCanceled;
         }
     }
 
     public boolean isRecycled() {
         synchronized (mLock) {
             return mRecycled;
         }
     }
 
     /**
      * Returns an exception if any, or null if the request was completed
      * successfully.
      */
     public IOException getException() {
         if (mSinkException != null) {
             return mSinkException;
         }
 
         validateNotRecycled();
 
-        int errorCode = nativeGetErrorCode(mUrlRequestPeer);
+        int errorCode = nativeGetErrorCode(mUrlRequestAdapter);
         switch (errorCode) {
             case UrlRequestError.SUCCESS:
                 return null;
             case UrlRequestError.UNKNOWN:
-                return new IOException(nativeGetErrorString(mUrlRequestPeer));
+                return new IOException(
+                        nativeGetErrorString(mUrlRequestAdapter));
             case UrlRequestError.MALFORMED_URL:
                 return new MalformedURLException("Malformed URL: " + mUrl);
             case UrlRequestError.CONNECTION_TIMED_OUT:
                 return new ConnectTimeoutException("Connection timed out");
             case UrlRequestError.UNKNOWN_HOST:
                 String host;
                 try {
                     host = new URL(mUrl).getHost();
                 } catch (MalformedURLException e) {
                     host = mUrl;
                 }
                 return new UnknownHostException("Unknown host: " + host);
             default:
                 throw new IllegalStateException(
                         "Unrecognized error code: " + errorCode);
         }
     }
 
     public int getHttpStatusCode() {
-        return nativeGetHttpStatusCode(mUrlRequestPeer);
+        return nativeGetHttpStatusCode(mUrlRequestAdapter);
     }
 
     /**
      * Content length as reported by the server. May be -1 or incorrect if the
      * server returns the wrong number, which happens even with Google servers.
      */
     public long getContentLength() {
         return mContentLength;
     }
 
     public String getContentType() {
         return mContentType;
     }
 
     public String getHeader(String name) {
         validateHeadersAvailable();
-        return nativeGetHeader(mUrlRequestPeer, name);
+        return nativeGetHeader(mUrlRequestAdapter, name);
     }
 
     // All response headers.
     public Map<String, List<String>> getAllHeaders() {
         validateHeadersAvailable();
         ResponseHeadersMap result = new ResponseHeadersMap();
-        nativeGetAllHeaders(mUrlRequestPeer, result);
+        nativeGetAllHeaders(mUrlRequestAdapter, result);
         return result;
     }
 
     /**
      * A callback invoked when the first chunk of the response has arrived.
      */
     @CalledByNative
     protected void onResponseStarted() {
-        mContentType = nativeGetContentType(mUrlRequestPeer);
-        mContentLength = nativeGetContentLength(mUrlRequestPeer);
+        mContentType = nativeGetContentType(mUrlRequestAdapter);
+        mContentLength = nativeGetContentLength(mUrlRequestAdapter);
         mHeadersAvailable = true;
     }
 
     /**
      * A callback invoked when the response has been fully consumed.
      */
     protected void onRequestComplete() {
     }
 
     /**
@@ skipping 26 matching lines @@
 
             if (mRecycled) {
                 return;
             }
             try {
                 mSink.close();
             } catch (IOException e) {
                 // Ignore
             }
             onRequestComplete();
-            nativeDestroyRequestPeer(mUrlRequestPeer);
-            mUrlRequestPeer = 0;
+            nativeDestroyRequestAdapter(mUrlRequestAdapter);
+            mUrlRequestAdapter = 0;
             mRecycled = true;
         }
     }
 
     /**
      * Appends header |name| with value |value| to |headersMap|.
      */
     @SuppressWarnings("unused")
     @CalledByNative
     private void onAppendResponseHeader(ResponseHeadersMap headersMap,
@@ skipping 49 matching lines @@
     private void validateHeadersAvailable() {
         if (!mHeadersAvailable) {
             throw new IllegalStateException("Response headers not available");
         }
     }
 
     public String getUrl() {
         return mUrl;
     }
 
-    private native long nativeCreateRequestPeer(long urlRequestContextPeer,
-            String url, int priority);
+    private native long nativeCreateRequestAdapter(
+            long urlRequestContextAdapter, String url, int priority);
 
-    private native void nativeAddHeader(long urlRequestPeer, String name,
+    private native void nativeAddHeader(long urlRequestAdapter, String name,
             String value);
 
-    private native void nativeSetMethod(long urlRequestPeer, String method);
+    private native void nativeSetMethod(long urlRequestAdapter, String method);
 
-    private native void nativeSetUploadData(long urlRequestPeer,
+    private native void nativeSetUploadData(long urlRequestAdapter,
             String contentType, byte[] content);
 
-    private native void nativeSetUploadChannel(long urlRequestPeer,
+    private native void nativeSetUploadChannel(long urlRequestAdapter,
             String contentType, long contentLength);
 
-    private native void nativeStart(long urlRequestPeer);
+    private native void nativeStart(long urlRequestAdapter);
 
-    private native void nativeCancel(long urlRequestPeer);
+    private native void nativeCancel(long urlRequestAdapter);
 
-    private native void nativeDestroyRequestPeer(long urlRequestPeer);
+    private native void nativeDestroyRequestAdapter(long urlRequestAdapter);
 
-    private native int nativeGetErrorCode(long urlRequestPeer);
+    private native int nativeGetErrorCode(long urlRequestAdapter);
 
-    private native int nativeGetHttpStatusCode(long urlRequestPeer);
+    private native int nativeGetHttpStatusCode(long urlRequestAdapter);
 
-    private native String nativeGetErrorString(long urlRequestPeer);
+    private native String nativeGetErrorString(long urlRequestAdapter);
 
-    private native String nativeGetContentType(long urlRequestPeer);
+    private native String nativeGetContentType(long urlRequestAdapter);
 
-    private native long nativeGetContentLength(long urlRequestPeer);
+    private native long nativeGetContentLength(long urlRequestAdapter);
 
-    private native String nativeGetHeader(long urlRequestPeer, String name);
+    private native String nativeGetHeader(long urlRequestAdapter, String name);
 
-    private native void nativeGetAllHeaders(long urlRequestPeer,
+    private native void nativeGetAllHeaders(long urlRequestAdapter,
             ResponseHeadersMap headers);
 
     // Explicit class to work around JNI-generator generics confusion.
     private class ResponseHeadersMap extends HashMap<String, List<String>> {
     }
 }