Merge changes from topics "setter_getter_fix", "use_header_block"

* changes:
  cronet: Use HeaderBlock for getHeaders API
  cronet: Address Setter/Getter related API linter issues

Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt

@@ -17,10 +17,10 @@
 package android.net.http.cts
 
 import android.net.http.ConnectionMigrationOptions
+import android.net.http.ConnectionMigrationOptions.MIGRATION_OPTION_ENABLED
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import kotlin.test.Test
-import kotlin.test.assertNotNull
+import kotlin.test.assertEquals
-import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
@@ -29,18 +29,20 @@ class ConnectionMigrationOptionsTest {
     @Test
     fun testConnectionMigrationOptions_enableDefaultNetworkMigration_returnSetValue() {
         val options =
-            ConnectionMigrationOptions.Builder().setEnableDefaultNetworkMigration(true).build()
+            ConnectionMigrationOptions.Builder()
+                    .setDefaultNetworkMigrationEnabled(MIGRATION_OPTION_ENABLED)
+                    .build()
 
-        assertNotNull(options.enableDefaultNetworkMigration)
+        assertEquals(MIGRATION_OPTION_ENABLED, options.defaultNetworkMigrationEnabled)
-        assertTrue(options.enableDefaultNetworkMigration!!)
     }
 
     @Test
     fun testConnectionMigrationOptions_enablePathDegradationMigration_returnSetValue() {
         val options =
-            ConnectionMigrationOptions.Builder().setEnablePathDegradationMigration(true).build()
+            ConnectionMigrationOptions.Builder()
+                    .setPathDegradationMigrationEnabled(MIGRATION_OPTION_ENABLED)
+                    .build()
 
-        assertNotNull(options.enablePathDegradationMigration)
+        assertEquals(MIGRATION_OPTION_ENABLED, options.pathDegradationMigrationEnabled)
-        assertTrue(options.enablePathDegradationMigration!!)
     }
 }

Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt

@@ -17,13 +17,14 @@
 package android.net.http.cts
 
 import android.net.http.DnsOptions
+import android.net.http.DnsOptions.DNS_OPTION_ENABLED
+import android.net.http.DnsOptions.DNS_OPTION_UNSPECIFIED
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import java.time.Duration
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
-import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
@@ -33,20 +34,22 @@ class DnsOptionsTest {
     fun testDnsOptions_defaultValues() {
         val options = DnsOptions.Builder().build()
 
-        assertNull(options.persistHostCache)
+        assertEquals(DNS_OPTION_UNSPECIFIED, options.persistHostCacheEnabled)
         assertNull(options.persistHostCachePeriod)
-        assertNull(options.enableStaleDns)
+        assertEquals(DNS_OPTION_UNSPECIFIED, options.staleDnsEnabled)
         assertNull(options.staleDnsOptions)
-        assertNull(options.useHttpStackDnsResolver)
+        assertEquals(DNS_OPTION_UNSPECIFIED, options.useHttpStackDnsResolverEnabled)
-        assertNull(options.preestablishConnectionsToStaleDnsResults)
+        assertEquals(DNS_OPTION_UNSPECIFIED,
+                options.preestablishConnectionsToStaleDnsResultsEnabled)
     }
 
     @Test
     fun testDnsOptions_persistHostCache_returnSetValue() {
-        val options = DnsOptions.Builder().setPersistHostCache(true).build()
+        val options = DnsOptions.Builder()
+                .setPersistHostCacheEnabled(DNS_OPTION_ENABLED)
+                .build()
 
-        assertNotNull(options.persistHostCache)
+        assertEquals(DNS_OPTION_ENABLED, options.persistHostCacheEnabled)
-        assertTrue(options.persistHostCache!!)
     }
 
     @Test
@@ -59,44 +62,48 @@ class DnsOptionsTest {
 
     @Test
     fun testDnsOptions_enableStaleDns_returnSetValue() {
-        val options = DnsOptions.Builder().setEnableStaleDns(true).build()
+        val options = DnsOptions.Builder()
+                .setStaleDnsEnabled(DNS_OPTION_ENABLED)
+                .build()
 
-        assertNotNull(options.enableStaleDns)
+        assertEquals(DNS_OPTION_ENABLED, options.staleDnsEnabled)
-        assertTrue(options.enableStaleDns!!)
     }
 
     @Test
     fun testDnsOptions_useHttpStackDnsResolver_returnsSetValue() {
-        val options = DnsOptions.Builder().setUseHttpStackDnsResolver(true).build()
+        val options = DnsOptions.Builder()
+                .setUseHttpStackDnsResolverEnabled(DNS_OPTION_ENABLED)
+                .build()
 
-        assertNotNull(options.useHttpStackDnsResolver)
+        assertEquals(DNS_OPTION_ENABLED, options.useHttpStackDnsResolverEnabled)
-        assertTrue(options.useHttpStackDnsResolver!!)
     }
 
     @Test
     fun testDnsOptions_preestablishConnectionsToStaleDnsResults_returnsSetValue() {
-        val options = DnsOptions.Builder().setPreestablishConnectionsToStaleDnsResults(true).build()
+        val options = DnsOptions.Builder()
+                .setPreestablishConnectionsToStaleDnsResultsEnabled(DNS_OPTION_ENABLED)
+                .build()
 
-        assertNotNull(options.preestablishConnectionsToStaleDnsResults)
+        assertEquals(DNS_OPTION_ENABLED,
-        assertTrue(options.preestablishConnectionsToStaleDnsResults!!)
+                options.preestablishConnectionsToStaleDnsResultsEnabled)
     }
 
     @Test
     fun testStaleDnsOptions_defaultValues() {
         val options = DnsOptions.StaleDnsOptions.Builder().build()
 
-        assertNull(options.allowCrossNetworkUsage)
+        assertEquals(DNS_OPTION_UNSPECIFIED, options.allowCrossNetworkUsageEnabled)
-        assertNull(options.freshLookupTimeoutMillis)
+        assertNull(options.freshLookupTimeout)
-        assertNull(options.maxExpiredDelayMillis)
+        assertNull(options.maxExpiredDelay)
-        assertNull(options.useStaleOnNameNotResolved)
+        assertEquals(DNS_OPTION_UNSPECIFIED, options.useStaleOnNameNotResolvedEnabled)
     }
 
     @Test
     fun testStaleDnsOptions_allowCrossNetworkUsage_returnsSetValue() {
-        val options = DnsOptions.StaleDnsOptions.Builder().setAllowCrossNetworkUsage(true).build()
+        val options = DnsOptions.StaleDnsOptions.Builder()
+                .setAllowCrossNetworkUsageEnabled(DNS_OPTION_ENABLED).build()
 
-        assertNotNull(options.allowCrossNetworkUsage)
+        assertEquals(DNS_OPTION_ENABLED, options.allowCrossNetworkUsageEnabled)
-        assertTrue(options.allowCrossNetworkUsage!!)
     }
 
     @Test
@@ -104,17 +111,17 @@ class DnsOptionsTest {
         val duration = Duration.ofMillis(12345)
         val options = DnsOptions.StaleDnsOptions.Builder().setFreshLookupTimeout(duration).build()
 
-        assertNotNull(options.freshLookupTimeoutMillis)
+        assertNotNull(options.freshLookupTimeout)
-        assertEquals(duration.toMillis(), options.freshLookupTimeoutMillis!!)
+        assertEquals(duration, options.freshLookupTimeout!!)
     }
 
     @Test
     fun testStaleDnsOptions_useStaleOnNameNotResolved_returnsSetValue() {
-        val options =
+        val options = DnsOptions.StaleDnsOptions.Builder()
-                DnsOptions.StaleDnsOptions.Builder().setUseStaleOnNameNotResolved(true).build()
+                .setUseStaleOnNameNotResolvedEnabled(DNS_OPTION_ENABLED)
+                .build()
 
-        assertNotNull(options.useStaleOnNameNotResolved)
+        assertEquals(DNS_OPTION_ENABLED, options.useStaleOnNameNotResolvedEnabled)
-        assertTrue(options.useStaleOnNameNotResolved!!)
     }
 
     @Test
@@ -122,7 +129,7 @@ class DnsOptionsTest {
         val duration = Duration.ofMillis(12345)
         val options = DnsOptions.StaleDnsOptions.Builder().setMaxExpiredDelay(duration).build()
 
-        assertNotNull(options.maxExpiredDelayMillis)
+        assertNotNull(options.maxExpiredDelay)
-        assertEquals(duration.toMillis(), options.maxExpiredDelayMillis!!)
+        assertEquals(duration, options.maxExpiredDelay!!)
     }
 }

Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt

@@ -26,7 +26,7 @@ class QuicOptionsTest {
     @Test
     fun testQuicOptions_defaultValues() {
         val quicOptions = QuicOptions.Builder().build()
-        assertThat(quicOptions.quicHostAllowlist).isEmpty()
+        assertThat(quicOptions.allowedQuicHosts).isEmpty()
         assertThat(quicOptions.handshakeUserAgent).isNull()
         // TODO(danstahr): idleConnectionTimeout getter should be public
         // assertThat(quicOptions.idleConnectionTimeout).isNull()
@@ -41,7 +41,7 @@ class QuicOptionsTest {
                 .addAllowedQuicHost("foo")
                 .addAllowedQuicHost("baz")
                 .build()
-        assertThat(quicOptions.quicHostAllowlist)
+        assertThat(quicOptions.allowedQuicHosts)
                 .containsExactly("foo", "bar", "baz")
                 .inOrder()
     }

Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java

@@ -158,7 +158,7 @@ public class UrlRequestTest {
         UploadDataProvider dataProvider = InMemoryUploadDataProvider.fromUtf8String("test");
         builder.setUploadDataProvider(dataProvider, DIRECT_EXECUTOR);
         builder.addHeader("Content-Type", "text/plain;charset=UTF-8");
-        builder.setAllowDirectExecutor(true);
+        builder.setDirectExecutorAllowed(true);
         builder.build().start();
         callback.blockForDone();
 

Cronet/tests/cts/src/android/net/http/cts/util/TestBidirectionalStreamCallback.java

@@ -26,6 +26,7 @@ import static org.junit.Assume.assumeThat;
 import static org.junit.Assume.assumeTrue;
 
 import android.net.http.BidirectionalStream;
+import android.net.http.HeaderBlock;
 import android.net.http.HttpException;
 import android.net.http.UrlResponseInfo;
 import android.os.ConditionVariable;
@@ -56,7 +57,7 @@ public class TestBidirectionalStreamCallback extends BidirectionalStream.Callbac
     public int mHttpResponseDataLength;
     public String mResponseAsString = "";
 
-    public UrlResponseInfo.HeaderBlock mTrailers;
+    public HeaderBlock mTrailers;
 
     private static final int READ_BUFFER_SIZE = 32 * 1024;
 
@@ -337,7 +338,7 @@ public class TestBidirectionalStreamCallback extends BidirectionalStream.Callbac
     public void onResponseTrailersReceived(
             BidirectionalStream stream,
             UrlResponseInfo info,
-            UrlResponseInfo.HeaderBlock trailers) {
+            HeaderBlock trailers) {
         checkOnValidThread();
         assertFalse(stream.isDone());
         assertNull(mError);

Tethering/common/TetheringLib/cronet_enabled/api/current.txt

@@ -5,26 +5,34 @@ package android.net.http {
     ctor public BidirectionalStream();
     method public abstract void cancel();
     method public abstract void flush();
+    method @NonNull public abstract android.net.http.HeaderBlock getHeaders();
+    method @NonNull public abstract String getHttpMethod();
+    method public abstract int getPriority();
+    method public abstract int getTrafficStatsTag();
+    method public abstract int getTrafficStatsUid();
+    method public abstract boolean hasTrafficStatsTag();
+    method public abstract boolean hasTrafficStatsUid();
+    method public abstract boolean isDelayRequestHeadersUntilFirstFlushEnabled();
     method public abstract boolean isDone();
     method public abstract void read(@NonNull java.nio.ByteBuffer);
     method public abstract void start();
     method public abstract void write(@NonNull java.nio.ByteBuffer, boolean);
+    field public static final int STREAM_PRIORITY_HIGHEST = 4; // 0x4
+    field public static final int STREAM_PRIORITY_IDLE = 0; // 0x0
+    field public static final int STREAM_PRIORITY_LOW = 2; // 0x2
+    field public static final int STREAM_PRIORITY_LOWEST = 1; // 0x1
+    field public static final int STREAM_PRIORITY_MEDIUM = 3; // 0x3
   }
 
   public abstract static class BidirectionalStream.Builder {
     ctor public BidirectionalStream.Builder();
     method @NonNull public abstract android.net.http.BidirectionalStream.Builder addHeader(@NonNull String, @NonNull String);
     method @NonNull public abstract android.net.http.BidirectionalStream build();
-    method @NonNull public abstract android.net.http.BidirectionalStream.Builder delayRequestHeadersUntilFirstFlush(boolean);
+    method @NonNull public abstract android.net.http.BidirectionalStream.Builder setDelayRequestHeadersUntilFirstFlushEnabled(boolean);
     method @NonNull public abstract android.net.http.BidirectionalStream.Builder setHttpMethod(@NonNull String);
     method @NonNull public abstract android.net.http.BidirectionalStream.Builder setPriority(int);
     method @NonNull public abstract android.net.http.BidirectionalStream.Builder setTrafficStatsTag(int);
     method @NonNull public abstract android.net.http.BidirectionalStream.Builder setTrafficStatsUid(int);
-    field public static final int STREAM_PRIORITY_HIGHEST = 4; // 0x4
-    field public static final int STREAM_PRIORITY_IDLE = 0; // 0x0
-    field public static final int STREAM_PRIORITY_LOW = 2; // 0x2
-    field public static final int STREAM_PRIORITY_LOWEST = 1; // 0x1
-    field public static final int STREAM_PRIORITY_MEDIUM = 3; // 0x3
   }
 
   public abstract static class BidirectionalStream.Callback {
@@ -33,7 +41,7 @@ package android.net.http {
     method public abstract void onFailed(@NonNull android.net.http.BidirectionalStream, @Nullable android.net.http.UrlResponseInfo, @NonNull android.net.http.HttpException);
     method public abstract void onReadCompleted(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo, @NonNull java.nio.ByteBuffer, boolean);
     method public abstract void onResponseHeadersReceived(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo);
-    method public void onResponseTrailersReceived(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo, @NonNull android.net.http.UrlResponseInfo.HeaderBlock);
+    method public void onResponseTrailersReceived(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo, @NonNull android.net.http.HeaderBlock);
     method public abstract void onStreamReady(@NonNull android.net.http.BidirectionalStream);
     method public abstract void onSucceeded(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo);
     method public abstract void onWriteCompleted(@NonNull android.net.http.BidirectionalStream, @NonNull android.net.http.UrlResponseInfo, @NonNull java.nio.ByteBuffer, boolean);
@@ -44,53 +52,65 @@ package android.net.http {
   }
 
   public class ConnectionMigrationOptions {
-    method @Nullable public Boolean getAllowNonDefaultNetworkUsage();
+    method public int getAllowNonDefaultNetworkUsageEnabled();
-    method @Nullable public Boolean getEnableDefaultNetworkMigration();
+    method public int getDefaultNetworkMigrationEnabled();
-    method @Nullable public Boolean getEnablePathDegradationMigration();
+    method public int getPathDegradationMigrationEnabled();
+    field public static final int MIGRATION_OPTION_DISABLED = 2; // 0x2
+    field public static final int MIGRATION_OPTION_ENABLED = 1; // 0x1
+    field public static final int MIGRATION_OPTION_UNSPECIFIED = 0; // 0x0
   }
 
   public static final class ConnectionMigrationOptions.Builder {
     ctor public ConnectionMigrationOptions.Builder();
     method @NonNull public android.net.http.ConnectionMigrationOptions build();
-    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setAllowNonDefaultNetworkUsage(boolean);
+    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setAllowNonDefaultNetworkUsageEnabled(int);
-    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setEnableDefaultNetworkMigration(boolean);
+    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setDefaultNetworkMigrationEnabled(int);
-    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setEnablePathDegradationMigration(boolean);
+    method @NonNull public android.net.http.ConnectionMigrationOptions.Builder setPathDegradationMigrationEnabled(int);
   }
 
   public final class DnsOptions {
-    method @Nullable public Boolean getEnableStaleDns();
+    method public int getPersistHostCacheEnabled();
-    method @Nullable public Boolean getPersistHostCache();
     method @Nullable public java.time.Duration getPersistHostCachePeriod();
-    method @Nullable public Boolean getPreestablishConnectionsToStaleDnsResults();
+    method public int getPreestablishConnectionsToStaleDnsResultsEnabled();
+    method public int getStaleDnsEnabled();
     method @Nullable public android.net.http.DnsOptions.StaleDnsOptions getStaleDnsOptions();
-    method @Nullable public Boolean getUseHttpStackDnsResolver();
+    method public int getUseHttpStackDnsResolverEnabled();
+    field public static final int DNS_OPTION_DISABLED = 2; // 0x2
+    field public static final int DNS_OPTION_ENABLED = 1; // 0x1
+    field public static final int DNS_OPTION_UNSPECIFIED = 0; // 0x0
   }
 
   public static final class DnsOptions.Builder {
     ctor public DnsOptions.Builder();
     method @NonNull public android.net.http.DnsOptions build();
-    method @NonNull public android.net.http.DnsOptions.Builder setEnableStaleDns(boolean);
+    method @NonNull public android.net.http.DnsOptions.Builder setPersistHostCacheEnabled(int);
-    method @NonNull public android.net.http.DnsOptions.Builder setPersistHostCache(boolean);
     method @NonNull public android.net.http.DnsOptions.Builder setPersistHostCachePeriod(@NonNull java.time.Duration);
-    method @NonNull public android.net.http.DnsOptions.Builder setPreestablishConnectionsToStaleDnsResults(boolean);
+    method @NonNull public android.net.http.DnsOptions.Builder setPreestablishConnectionsToStaleDnsResultsEnabled(int);
+    method @NonNull public android.net.http.DnsOptions.Builder setStaleDnsEnabled(int);
     method @NonNull public android.net.http.DnsOptions.Builder setStaleDnsOptions(@NonNull android.net.http.DnsOptions.StaleDnsOptions);
-    method @NonNull public android.net.http.DnsOptions.Builder setUseHttpStackDnsResolver(boolean);
+    method @NonNull public android.net.http.DnsOptions.Builder setUseHttpStackDnsResolverEnabled(int);
   }
 
   public static class DnsOptions.StaleDnsOptions {
-    method @Nullable public Boolean getAllowCrossNetworkUsage();
+    method public int getAllowCrossNetworkUsageEnabled();
-    method @Nullable public Long getFreshLookupTimeoutMillis();
+    method @Nullable public java.time.Duration getFreshLookupTimeout();
-    method @Nullable public Long getMaxExpiredDelayMillis();
+    method @Nullable public java.time.Duration getMaxExpiredDelay();
-    method @Nullable public Boolean getUseStaleOnNameNotResolved();
+    method public int getUseStaleOnNameNotResolvedEnabled();
   }
 
   public static final class DnsOptions.StaleDnsOptions.Builder {
     ctor public DnsOptions.StaleDnsOptions.Builder();
     method @NonNull public android.net.http.DnsOptions.StaleDnsOptions build();
-    method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setAllowCrossNetworkUsage(boolean);
+    method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setAllowCrossNetworkUsageEnabled(int);
     method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setFreshLookupTimeout(@NonNull java.time.Duration);
     method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setMaxExpiredDelay(@NonNull java.time.Duration);
-    method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setUseStaleOnNameNotResolved(boolean);
+    method @NonNull public android.net.http.DnsOptions.StaleDnsOptions.Builder setUseStaleOnNameNotResolvedEnabled(int);
+  }
+
+  public abstract class HeaderBlock {
+    ctor public HeaderBlock();
+    method @NonNull public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAsList();
+    method @NonNull public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAsMap();
   }
 
   public abstract class HttpEngine {
@@ -156,10 +176,10 @@ package android.net.http {
   }
 
   public class QuicOptions {
+    method @NonNull public java.util.Set<java.lang.String> getAllowedQuicHosts();
     method @Nullable public String getHandshakeUserAgent();
     method @Nullable public java.time.Duration getIdleConnectionTimeout();
     method @Nullable public Integer getInMemoryServerConfigsCacheSize();
-    method @NonNull public java.util.Set<java.lang.String> getQuicHostAllowlist();
   }
 
   public static final class QuicOptions.Builder {
@@ -190,28 +210,37 @@ package android.net.http {
   public abstract class UrlRequest {
     method public abstract void cancel();
     method public abstract void followRedirect();
+    method @NonNull public abstract android.net.http.HeaderBlock getHeaders();
+    method @Nullable public abstract String getHttpMethod();
+    method public abstract int getPriority();
     method public abstract void getStatus(@NonNull android.net.http.UrlRequest.StatusListener);
+    method public abstract int getTrafficStatsTag();
+    method public abstract int getTrafficStatsUid();
+    method public abstract boolean hasTrafficStatsTag();
+    method public abstract boolean hasTrafficStatsUid();
+    method public abstract boolean isCacheDisabled();
+    method public abstract boolean isDirectExecutorAllowed();
     method public abstract boolean isDone();
     method public abstract void read(@NonNull java.nio.ByteBuffer);
     method public abstract void start();
+    field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
+    field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
+    field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
+    field public static final int REQUEST_PRIORITY_LOWEST = 1; // 0x1
+    field public static final int REQUEST_PRIORITY_MEDIUM = 3; // 0x3
   }
 
   public abstract static class UrlRequest.Builder {
     method @NonNull public abstract android.net.http.UrlRequest.Builder addHeader(@NonNull String, @NonNull String);
     method @NonNull public abstract android.net.http.UrlRequest.Builder bindToNetwork(@Nullable android.net.Network);
     method @NonNull public abstract android.net.http.UrlRequest build();
-    method @NonNull public abstract android.net.http.UrlRequest.Builder setAllowDirectExecutor(boolean);
+    method @NonNull public abstract android.net.http.UrlRequest.Builder setCacheDisabled(boolean);
-    method @NonNull public abstract android.net.http.UrlRequest.Builder setDisableCache(boolean);
+    method @NonNull public abstract android.net.http.UrlRequest.Builder setDirectExecutorAllowed(boolean);
     method @NonNull public abstract android.net.http.UrlRequest.Builder setHttpMethod(@NonNull String);
     method @NonNull public abstract android.net.http.UrlRequest.Builder setPriority(int);
     method @NonNull public abstract android.net.http.UrlRequest.Builder setTrafficStatsTag(int);
     method @NonNull public abstract android.net.http.UrlRequest.Builder setTrafficStatsUid(int);
     method @NonNull public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(@NonNull android.net.http.UploadDataProvider, @NonNull java.util.concurrent.Executor);
-    field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
-    field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
-    field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
-    field public static final int REQUEST_PRIORITY_LOWEST = 1; // 0x1
-    field public static final int REQUEST_PRIORITY_MEDIUM = 3; // 0x3
   }
 
   public abstract static class UrlRequest.Callback {
@@ -249,7 +278,7 @@ package android.net.http {
 
   public abstract class UrlResponseInfo {
     ctor public UrlResponseInfo();
-    method @NonNull public abstract android.net.http.UrlResponseInfo.HeaderBlock getHeaders();
+    method @NonNull public abstract android.net.http.HeaderBlock getHeaders();
     method public abstract int getHttpStatusCode();
     method @NonNull public abstract String getHttpStatusText();
     method @NonNull public abstract String getNegotiatedProtocol();
@@ -259,11 +288,5 @@ package android.net.http {
     method public abstract boolean wasCached();
   }
 
-  public abstract static class UrlResponseInfo.HeaderBlock {
-    ctor public UrlResponseInfo.HeaderBlock();
-    method @NonNull public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAsList();
-    method @NonNull public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAsMap();
-  }
-
 }