diff --git a/core/src/main/java/io/grpc/Internal.java b/core/src/main/java/io/grpc/Internal.java
index e4cb1a4..479c1b1 100644
--- a/core/src/main/java/io/grpc/Internal.java
+++ b/core/src/main/java/io/grpc/Internal.java
@@ -41,7 +41,7 @@
  * Annotates a program element (class, method, package etc) which is internal to gRPC, not part of
  * the public API, and should not be used by users of gRPC.
  *
- * <p>However, if you want to implement a custom {@link LoadBalancer2}, an alternative transport, or
+ * <p>However, if you want to implement a custom {@link LoadBalancer}, an alternative transport, or
  * anything else that will be wired into gRPC library, you may use the internal parts.  Please
  * consult the gRPC team first, because internal APIs don't have the same API stability guarantee as
  * the public APIs do.
diff --git a/core/src/main/java/io/grpc/LoadBalancer.java b/core/src/main/java/io/grpc/LoadBalancer.java
new file mode 100644
index 0000000..1db9d36
--- /dev/null
+++ b/core/src/main/java/io/grpc/LoadBalancer.java
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2016, Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ *    * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.grpc;
+
+import com.google.common.base.Preconditions;
+import java.util.List;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
+ * channel a usable subchannel when asked.
+ *
+ * <h3>Overview</h3>
+ *
+ * <p>A LoadBalancer typically implements three interfaces:
+ * <ol>
+ *   <li>{@link LoadBalancer} is the main interface.  All methods on it are invoked sequentially
+ *       from the Channel Executor.  It receives the results from the {@link NameResolver}, updates
+ *       of subchannels' connectivity states, and the channel's request for the LoadBalancer to
+ *       shutdown.</li>
+ *   <li>{@link SubchannelPicker SubchannelPicker} does the actual load-balancing work.  It selects
+ *       a {@link Subchannel Subchannel} for each new RPC.</li>
+ *   <li>{@link Factory Factory} creates a new {@link LoadBalancer} instance.
+ * </ol>
+ *
+ * <p>{@link Helper Helper} is implemented by gRPC library and provided to {@link Factory
+ * Factory}. It provides functionalities that a {@code LoadBalancer} implementation would typically
+ * need.
+ *
+ * <h3>Channel Executor</h3>
+ *
+ * <p>Channel Executor is an internal executor of the channel, which is used to serialize all the
+ * callback methods on the {@link LoadBalancer} interface, thus the balancer implementation doesn't
+ * need to worry about synchronization among them.  However, the actual thread of the Channel
+ * Executor is typically the network thread, thus the following rules must be followed to prevent
+ * blocking or even dead-locking in a network
+ *
+ * <ol>
+ *
+ *   <li><strong>Never block in Channel Executor</strong>.  The callback methods must return
+ *   quickly.  Examples or work that must be avoided: CPU-intensive calculation, waiting on
+ *   synchronization primitives, blocking I/O, blocking RPCs, etc.</li>
+ *
+ *   <li><strong>Avoid calling into other components with lock held</strong>.  Channel Executor may
+ *   run callbacks under a lock, e.g., the transport lock of OkHttp.  If your LoadBalancer has a
+ *   lock, holds the lock in a callback method (e.g., {@link #handleSubchannelState
+ *   handleSubchannelState()}) while calling into another class that may involve locks, be cautious
+ *   of deadlock.  Generally you wouldn't need any locking in the LoadBalancer.</li>
+ *
+ * </ol>
+ *
+ * <p>{@link Helper#runSerialized Helper.runSerialized()} allows you to schedule a task to be run in
+ * the Channel Executor.
+ *
+ * <h3>The canonical implementation pattern</h3>
+ *
+ * <p>A {@link LoadBalancer} keeps states like the latest addresses from NameResolver, the
+ * Subchannel(s) and their latest connectivity states.  These states are mutated within the Channel
+ * Executor.
+ *
+ * <p>A typical {@link SubchannelPicker SubchannelPicker} holds a snapshot of these states.  It may
+ * have its own states, e.g., a picker from a round-robin load-balancer may keep a pointer to the
+ * next Subchannel, which are typically mutated by multiple threads.  The picker should only mutate
+ * its own state, and should not mutate or re-acquire the states of the LoadBalancer.  This way the
+ * picker only needs to synchronize its own states, which is typically trivial to implement.
+ *
+ * <p>When the LoadBalancer states changes, e.g., Subchannels has become or stopped being READY, and
+ * we want subsequent RPCs to use the latest list of READY Subchannels, LoadBalancer would create
+ * a new picker, which holds a snapshot of the latest Subchannel list.  Refer to the javadoc of
+ * {@link #handleSubchannelState handleSubchannelState()} how to do this properly.
+ *
+ * <p>No synchronization should be necessary between LoadBalancer and its pickers if you follow
+ * the pattern above.  It may be possible to implement in a different way, but that would usually
+ * result in more complicated threading.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+@NotThreadSafe
+public abstract class LoadBalancer {
+  /**
+   * Handles newly resolved server groups and metadata attributes from name resolution system.
+   * {@code servers} contained in {@link ResolvedServerInfoGroup} should be considered equivalent
+   * but may be flattened into a single list if needed.
+   *
+   * <p>Implementations should not modify the given {@code servers}.
+   *
+   * @param servers the resolved server addresses, never empty.
+   * @param attributes extra metadata from naming system.
+   */
+  public abstract void handleResolvedAddresses(
+      List<ResolvedServerInfoGroup> servers, Attributes attributes);
+
+  /**
+   * Handles an error from the name resolution system.
+   *
+   * @param error a non-OK status
+   */
+  public abstract void handleNameResolutionError(Status error);
+
+  /**
+   * Handles a state change on a Subchannel.
+   *
+   * <p>The initial state of a Subchannel is IDLE. You won't get a notification for the initial IDLE
+   * state.
+   *
+   * <p>If the new state is not SHUTDOWN, this method should create a new picker and call {@link
+   * Helper#updatePicker Helper.updatePicker()}.  Failing to do so may result in unnecessary delays
+   * of RPCs. Please refer to {@link PickResult#withSubchannel PickResult.withSubchannel()}'s
+   * javadoc for more information.
+   *
+   * <p>SHUTDOWN can only happen in two cases.  One is that LoadBalancer called {@link
+   * Subchannel#shutdown} earlier, thus it should have already discarded this Subchannel.  The other
+   * is that Channel is doing a {@link ManagedChannel#shutdownNow forced shutdown} or has already
+   * terminated, thus there won't be further requests to LoadBalancer.  Therefore, SHUTDOWN can be
+   * safely ignored.
+   *
+   * @param subchannel the involved Subchannel
+   * @param stateInfo the new state
+   */
+  public abstract void handleSubchannelState(
+      Subchannel subchannel, ConnectivityStateInfo stateInfo);
+
+  /**
+   * The channel asks the load-balancer to shutdown.  No more callbacks will be called after this
+   * method.  The implementation should shutdown all Subchannels and OOB channels, and do any other
+   * cleanup as necessary.
+   */
+  public abstract void shutdown();
+
+  /**
+   * The main balancing logic.  It <strong>must be thread-safe</strong>. Typically it should only
+   * synchronize on its own state, and avoid synchronizing with the LoadBalancer's state.
+   */
+  @ThreadSafe
+  public abstract static class SubchannelPicker {
+    /**
+     * Make a balancing decision for a new RPC.
+     *
+     * @param affinity the affinity attributes provided via {@link CallOptions#withAffinity}
+     * @param headers the headers container of the RPC. It can be mutated within this method.
+     */
+    public abstract PickResult pickSubchannel(Attributes affinity, Metadata headers);
+  }
+
+  /**
+   * A balancing decision made by {@link SubchannelPicker SubchannelPicker} for an RPC.
+   *
+   * <p>The outcome of the decision will be one of the following:
+   * <ul>
+   *   <li>Proceed: if a Subchannel is provided via {@link #withSubchannel withSubchannel()}, and is
+   *       in READY state when the RPC tries to start on it, the RPC will proceed on that
+   *       Subchannel.</li>
+   *   <li>Error: if an error is provided via {@link #withError withError()}, and the RPC is not
+   *       wait-for-ready (i.e., {@link CallOptions#withWaitForReady} was not called), the RPC will
+   *       fail immediately with the given error.</li>
+   *   <li>Buffer: in all other cases, the RPC will be buffered in the Channel, until the next
+   *       picker is provided via {@link Helper#updatePicker Helper.updatePicker()}, when the RPC
+   *       will go through the same picking process again.</li>
+   * </ul>
+   */
+  @Immutable
+  public static final class PickResult {
+    private static final PickResult NO_RESULT = new PickResult(null, Status.OK);
+
+    @Nullable private final Subchannel subchannel;
+    // An error to be propagated to the application if subchannel == null
+    // Or OK if there is no error.
+    // subchannel being null and error being OK means RPC needs to wait
+    private final Status status;
+
+    private PickResult(Subchannel subchannel, Status status) {
+      this.subchannel = subchannel;
+      this.status = Preconditions.checkNotNull(status, "status");
+    }
+
+    /**
+     * A decision to proceed the RPC on a Subchannel.
+     *
+     * <p>Only Subchannels returned by {@link Helper#createSubchannel Helper.createSubchannel()}
+     * will work.  DO NOT try to use your own implementations of Subchannels, as they won't work.
+     *
+     * <p>When the RPC tries to use the return Subchannel, which is briefly after this method
+     * returns, the state of the Subchannel will decide where the RPC would go:
+     *
+     * <ul>
+     *   <li>READY: the RPC will proceed on this Subchannel.</li>
+     *   <li>IDLE: the RPC will be buffered.  Subchannel will attempt to create connection.</li>
+     *   <li>All other states: the RPC will be buffered.</li>
+     * </ul>
+     *
+     * <p><strong>All buffered RPCs will stay buffered</strong> until the next call of {@link
+     * Helper#updatePicker Helper.updatePicker()}, which will trigger a new picking process.
+     *
+     * <p>Note that Subchannel's state may change at the same time the picker is making the
+     * decision, which means the decision may be made with (to-be) outdated information.  For
+     * example, a picker may return a Subchannel known to be READY, but it has become IDLE when is
+     * about to be used by the RPC, which makes the RPC to be buffered.  The LoadBalancer will soon
+     * learn about the Subchannels' transition from READY to IDLE, create a new picker and allow the
+     * RPC to use another READY transport if there is any.
+     *
+     * <p>You will want to avoid running into a situation where there are READY Subchannels out
+     * there but some RPCs are still buffered for longer than a brief time.
+     * <ul>
+     *   <li>This can happen if you return Subchannels with states other than READY and IDLE.  For
+     *       example, suppose you round-robin on 2 Subchannels, in READY and CONNECTING states
+     *       respectively.  If the picker ignores the state and pick them equally, 50% of RPCs will
+     *       be stuck in buffered state until both Subchannels are READY.</li>
+     *   <li>This can also happen if you don't create a new picker at key state changes of
+     *       Subchannels.  Take the above round-robin example again.  Suppose you do pick only READY
+     *       and IDLE Subchannels, and initially both Subchannels are READY.  Now one becomes IDLE,
+     *       then CONNECTING and stays CONNECTING for a long time.  If you don't create a new picker
+     *       in response to the CONNECTING state to exclude that Subchannel, 50% of RPCs will hit it
+     *       and be buffered even though the other Subchannel is READY.</li>
+     * </ul>
+     *
+     * <p>In order to prevent unnecessary delay of RPCs, the rules of thumb are:
+     * <ol>
+     *   <li>The picker should only pick Subchannels that are known as READY or IDLE.  Whether to
+     *       pick IDLE Subchannels depends on whether you want Subchannels to connect on-demand or
+     *       actively:
+     *       <ul>
+     *         <li>If you want connect-on-demand, include IDLE Subchannels in your pick results,
+     *             because when an RPC tries to use an IDLE Subchannel, the Subchannel will try to
+     *             connect.</li>
+     *         <li>If you want Subchannels to be always connected even when there is no RPC, you
+     *             would call {@link Subchannel#requestConnection Subchannel.requestConnection()}
+     *             whenever the Subchannel has transitioned to IDLE, then you don't need to include
+     *             IDLE Subchannels in your pick results.</li>
+     *       </ul></li>
+     *   <li>Always create a new picker and call {@link Helper#updatePicker Helper.updatePicker()}
+     *       whenever {@link #handleSubchannelState handleSubchannelState()} is called, unless the
+     *       new state is SHUTDOWN. See {@code handleSubchannelState}'s javadoc for more
+     *       details.</li>
+     * </ol>
+     */
+    public static PickResult withSubchannel(Subchannel subchannel) {
+      return new PickResult(Preconditions.checkNotNull(subchannel, "subchannel"), Status.OK);
+    }
+
+    /**
+     * A decision to report a connectivity error to the RPC.  If the RPC is {@link
+     * CallOptions#withWaitForReady wait-for-ready}, it will stay buffered.  Otherwise, it will fail
+     * with the given error.
+     *
+     * @param error the error status.  Must not be OK.
+     */
+    public static PickResult withError(Status error) {
+      Preconditions.checkArgument(!error.isOk(), "error status shouldn't be OK");
+      return new PickResult(null, error);
+    }
+
+    /**
+     * No decision could be made.  The RPC will stay buffered.
+     */
+    public static PickResult withNoResult() {
+      return NO_RESULT;
+    }
+
+    /**
+     * The Subchannel if this result was created by {@link #withSubchannel withSubchannel()}, or
+     * null otherwise.
+     */
+    @Nullable
+    public Subchannel getSubchannel() {
+      return subchannel;
+    }
+
+    /**
+     * The status associated with this result.  Non-{@code OK} if created with {@link #withError
+     * withError}, or {@code OK} otherwise.
+     */
+    public Status getStatus() {
+      return status;
+    }
+
+    @Override
+    public String toString() {
+      return "[subchannel=" + subchannel + " status=" + status + "]";
+    }
+  }
+
+  /**
+   * Provides essentials for LoadBalancer implementations.
+   */
+  @ThreadSafe
+  public abstract static class Helper {
+    /**
+     * Creates a Subchannel, which is a logical connection to the given group of addresses which are
+     * considered equivalent.  The {@code attrs} are custom attributes associated with this
+     * Subchannel, and can be accessed later through {@link Subchannel#getAttributes
+     * Subchannel.getAttributes()}.
+     *
+     * <p>The LoadBalancer is responsible for closing unused Subchannels, and closing all
+     * Subchannels within {@link #shutdown}.
+     */
+    public abstract Subchannel createSubchannel(EquivalentAddressGroup addrs, Attributes attrs);
+
+    /**
+     * Out-of-band channel for LoadBalancer’s own RPC needs, e.g., talking to an external
+     * load-balancer service.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     */
+    public abstract ManagedChannel createOobChannel(
+        EquivalentAddressGroup eag, String authority);
+
+    /**
+     * Set a new picker to the channel.
+     *
+     * <p>When a new picker is provided via {@code updatePicker()}, the channel will apply the
+     * picker on all buffered RPCs, by calling {@link SubchannelPicker#pickSubchannel
+     * SubchannelPicker.pickSubchannel()}.
+     *
+     * <p>The channel will hold the picker and use it for all RPCs, until {@code updatePicker()} is
+     * called again and a new picker replaces the old one.  If {@code updatePicker()} has never been
+     * called, the channel will buffer all RPCs until a picker is provided.
+     */
+    public abstract void updatePicker(SubchannelPicker picker);
+
+    /**
+     * Schedule a task to be run in the Channel Executor, which serializes the task with the
+     * callback methods on the {@link LoadBalancer} interface.
+     */
+    public abstract void runSerialized(Runnable task);
+
+    /**
+     * Returns the NameResolver of the channel.
+     */
+    public abstract NameResolver.Factory getNameResolverFactory();
+
+    /**
+     * Returns the authority string of the channel, which is derived from the DNS-style target name.
+     */
+    public abstract String getAuthority();
+  }
+
+  /**
+   * A logical connection to a server, or a group of equivalent servers represented by an {@link 
+   * EquivalentAddressGroup}.
+   *
+   * <p>It maintains at most one physical connection (aka transport) for sending new RPCs, while
+   * also keeps track of previous transports that has been shut down but not terminated yet.
+   *
+   * <p>If there isn't an active transport yet, and an RPC is assigned to the Subchannel, it will
+   * create a new transport.  It won't actively create transports otherwise.  {@link
+   * #requestConnection requestConnection()} can be used to ask Subchannel to create a transport if
+   * there isn't any.
+   */
+  @ThreadSafe
+  public abstract static class Subchannel {
+    /**
+     * Shuts down the Subchannel.  After this method is called, this Subchannel should no longer
+     * be returned by the latest {@link SubchannelPicker picker}, and can be safely discarded.
+     */
+    public abstract void shutdown();
+
+    /**
+     * Asks the Subchannel to create a connection (aka transport), if there isn't an active one.
+     */
+    public abstract void requestConnection();
+
+    /**
+     * Returns the addresses that this Subchannel is bound to.
+     */
+    public abstract EquivalentAddressGroup getAddresses();
+
+    /**
+     * The same attributes passed to {@link Helper#createSubchannel Helper.createSubchannel()}.
+     * LoadBalancer can use it to attach additional information here, e.g., the shard this
+     * Subchannel belongs to.
+     */
+    public abstract Attributes getAttributes();
+  }
+
+  @ThreadSafe
+  public abstract static class Factory {
+    /**
+     * Creates a {@link LoadBalancer} that will be used inside a channel.
+     */
+    public abstract LoadBalancer newLoadBalancer(Helper helper);
+  }
+}
diff --git a/core/src/main/java/io/grpc/LoadBalancer2.java b/core/src/main/java/io/grpc/LoadBalancer2.java
index a4772df..fe0b0f5 100644
--- a/core/src/main/java/io/grpc/LoadBalancer2.java
+++ b/core/src/main/java/io/grpc/LoadBalancer2.java
@@ -31,390 +31,13 @@
 
 package io.grpc;
 
-import com.google.common.base.Preconditions;
-import java.util.List;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.Immutable;
-import javax.annotation.concurrent.NotThreadSafe;
-import javax.annotation.concurrent.ThreadSafe;
-
 /**
- * A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
- * channel a usable subchannel when asked.  This is the new interface that will replace {@link
- * LoadBalancer2}.
+ * An alias for {@link LoadBalancer}.
  *
- * <p><strong>IMPORTANT NOTICE FOR IMPLEMENTORS: </strong>The name of this class is temporary.  It
- * will be renamed to {@code LoadBalancer} eventually.  Make sure you have read through <a
- * href="https://github.com/grpc/grpc-java/issues/2656" target="_blank">#2656</a> to understand the
- * transition path.
- *
- * <h3>Overview</h3>
- *
- * <p>A LoadBalancer typically implements three interfaces:
- * <ol>
- *   <li>{@link LoadBalancer2} is the main interface.  All methods on it are invoked sequentially
- *       from the Channel Executor.  It receives the results from the {@link NameResolver}, updates
- *       of subchannels' connectivity states, and the channel's request for the LoadBalancer to
- *       shutdown.</li>
- *   <li>{@link SubchannelPicker SubchannelPicker} does the actual load-balancing work.  It selects
- *       a {@link Subchannel Subchannel} for each new RPC.</li>
- *   <li>{@link Factory Factory} creates a new {@link LoadBalancer2} instance.
- * </ol>
- *
- * <p>{@link Helper Helper} is implemented by gRPC library and provided to {@link Factory
- * Factory}. It provides functionalities that a {@code LoadBalancer2} implementation would typically
- * need.
- *
- * <h3>Channel Executor</h3>
- *
- * <p>Channel Executor is an internal executor of the channel, which is used to serialize all the
- * callback methods on the {@link LoadBalancer2} interface, thus the balancer implementation doesn't
- * need to worry about synchronization among them.  However, the actual thread of the Channel
- * Executor is typically the network thread, thus the following rules must be followed to prevent
- * blocking or even dead-locking in a network
- *
- * <ol>
- *
- *   <li><strong>Never block in Channel Executor</strong>.  The callback methods must return
- *   quickly.  Examples or work that must be avoided: CPU-intensive calculation, waiting on
- *   synchronization primitives, blocking I/O, blocking RPCs, etc.</li>
- *
- *   <li><strong>Avoid calling into other components with lock held</strong>.  Channel Executor may
- *   run callbacks under a lock, e.g., the transport lock of OkHttp.  If your LoadBalancer has a
- *   lock, holds the lock in a callback method (e.g., {@link #handleSubchannelState
- *   handleSubchannelState()}) while calling into another class that may involve locks, be cautious
- *   of deadlock.  Generally you wouldn't need any locking in the LoadBalancer.</li>
- *
- * </ol>
- *
- * <p>{@link Helper#runSerialized Helper.runSerialized()} allows you to schedule a task to be run in
- * the Channel Executor.
- *
- * <h3>The canonical implementation pattern</h3>
- *
- * <p>A {@link LoadBalancer2} keeps states like the latest addresses from NameResolver, the
- * Subchannel(s) and their latest connectivity states.  These states are mutated within the Channel
- * Executor.
- *
- * <p>A typical {@link SubchannelPicker SubchannelPicker} holds a snapshot of these states.  It may
- * have its own states, e.g., a picker from a round-robin load-balancer may keep a pointer to the
- * next Subchannel, which are typically mutated by multiple threads.  The picker should only mutate
- * its own state, and should not mutate or re-acquire the states of the LoadBalancer.  This way the
- * picker only needs to synchronize its own states, which is typically trivial to implement.
- *
- * <p>When the LoadBalancer states changes, e.g., Subchannels has become or stopped being READY, and
- * we want subsequent RPCs to use the latest list of READY Subchannels, LoadBalancer would create
- * a new picker, which holds a snapshot of the latest Subchannel list.  Refer to the javadoc of
- * {@link #handleSubchannelState handleSubchannelState()} how to do this properly.
- *
- * <p>No synchronization should be necessary between LoadBalancer and its pickers if you follow
- * the pattern above.  It may be possible to implement in a different way, but that would usually
- * result in more complicated threading.
+ * @deprecated this is going to be deleted in the next minor release.  Use {@link LoadBalancer}
+ *             instead.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-@NotThreadSafe
-public abstract class LoadBalancer2 {
-  /**
-   * Handles newly resolved server groups and metadata attributes from name resolution system.
-   * {@code servers} contained in {@link ResolvedServerInfoGroup} should be considered equivalent
-   * but may be flattened into a single list if needed.
-   *
-   * <p>Implementations should not modify the given {@code servers}.
-   *
-   * @param servers the resolved server addresses, never empty.
-   * @param attributes extra metadata from naming system.
-   */
-  public abstract void handleResolvedAddresses(
-      List<ResolvedServerInfoGroup> servers, Attributes attributes);
-
-  /**
-   * Handles an error from the name resolution system.
-   *
-   * @param error a non-OK status
-   */
-  public abstract void handleNameResolutionError(Status error);
-
-  /**
-   * Handles a state change on a Subchannel.
-   *
-   * <p>The initial state of a Subchannel is IDLE. You won't get a notification for the initial IDLE
-   * state.
-   *
-   * <p>If the new state is not SHUTDOWN, this method should create a new picker and call {@link
-   * Helper#updatePicker Helper.updatePicker()}.  Failing to do so may result in unnecessary delays
-   * of RPCs. Please refer to {@link PickResult#withSubchannel PickResult.withSubchannel()}'s
-   * javadoc for more information.
-   *
-   * <p>SHUTDOWN can only happen in two cases.  One is that LoadBalancer called {@link
-   * Subchannel#shutdown} earlier, thus it should have already discarded this Subchannel.  The other
-   * is that Channel is doing a {@link ManagedChannel#shutdownNow forced shutdown} or has already
-   * terminated, thus there won't be further requests to LoadBalancer.  Therefore, SHUTDOWN can be
-   * safely ignored.
-   *
-   * @param subchannel the involved Subchannel
-   * @param stateInfo the new state
-   */
-  public abstract void handleSubchannelState(
-      Subchannel subchannel, ConnectivityStateInfo stateInfo);
-
-  /**
-   * The channel asks the load-balancer to shutdown.  No more callbacks will be called after this
-   * method.  The implementation should shutdown all Subchannels and OOB channels, and do any other
-   * cleanup as necessary.
-   */
-  public abstract void shutdown();
-
-  /**
-   * The main balancing logic.  It <strong>must be thread-safe</strong>. Typically it should only
-   * synchronize on its own state, and avoid synchronizing with the LoadBalancer's state.
-   */
-  @ThreadSafe
-  public abstract static class SubchannelPicker {
-    /**
-     * Make a balancing decision for a new RPC.
-     *
-     * @param affinity the affinity attributes provided via {@link CallOptions#withAffinity}
-     * @param headers the headers container of the RPC. It can be mutated within this method.
-     */
-    public abstract PickResult pickSubchannel(Attributes affinity, Metadata headers);
-  }
-
-  /**
-   * A balancing decision made by {@link SubchannelPicker SubchannelPicker} for an RPC.
-   *
-   * <p>The outcome of the decision will be one of the following:
-   * <ul>
-   *   <li>Proceed: if a Subchannel is provided via {@link #withSubchannel withSubchannel()}, and is
-   *       in READY state when the RPC tries to start on it, the RPC will proceed on that
-   *       Subchannel.</li>
-   *   <li>Error: if an error is provided via {@link #withError withError()}, and the RPC is not
-   *       wait-for-ready (i.e., {@link CallOptions#withWaitForReady} was not called), the RPC will
-   *       fail immediately with the given error.</li>
-   *   <li>Buffer: in all other cases, the RPC will be buffered in the Channel, until the next
-   *       picker is provided via {@link Helper#updatePicker Helper.updatePicker()}, when the RPC
-   *       will go through the same picking process again.</li>
-   * </ul>
-   */
-  @Immutable
-  public static final class PickResult {
-    private static final PickResult NO_RESULT = new PickResult(null, Status.OK);
-
-    @Nullable private final Subchannel subchannel;
-    // An error to be propagated to the application if subchannel == null
-    // Or OK if there is no error.
-    // subchannel being null and error being OK means RPC needs to wait
-    private final Status status;
-
-    private PickResult(Subchannel subchannel, Status status) {
-      this.subchannel = subchannel;
-      this.status = Preconditions.checkNotNull(status, "status");
-    }
-
-    /**
-     * A decision to proceed the RPC on a Subchannel.
-     *
-     * <p>Only Subchannels returned by {@link Helper#createSubchannel Helper.createSubchannel()}
-     * will work.  DO NOT try to use your own implementations of Subchannels, as they won't work.
-     *
-     * <p>When the RPC tries to use the return Subchannel, which is briefly after this method
-     * returns, the state of the Subchannel will decide where the RPC would go:
-     *
-     * <ul>
-     *   <li>READY: the RPC will proceed on this Subchannel.</li>
-     *   <li>IDLE: the RPC will be buffered.  Subchannel will attempt to create connection.</li>
-     *   <li>All other states: the RPC will be buffered.</li>
-     * </ul>
-     *
-     * <p><strong>All buffered RPCs will stay buffered</strong> until the next call of {@link
-     * Helper#updatePicker Helper.updatePicker()}, which will trigger a new picking process.
-     *
-     * <p>Note that Subchannel's state may change at the same time the picker is making the
-     * decision, which means the decision may be made with (to-be) outdated information.  For
-     * example, a picker may return a Subchannel known to be READY, but it has become IDLE when is
-     * about to be used by the RPC, which makes the RPC to be buffered.  The LoadBalancer will soon
-     * learn about the Subchannels' transition from READY to IDLE, create a new picker and allow the
-     * RPC to use another READY transport if there is any.
-     *
-     * <p>You will want to avoid running into a situation where there are READY Subchannels out
-     * there but some RPCs are still buffered for longer than a brief time.
-     * <ul>
-     *   <li>This can happen if you return Subchannels with states other than READY and IDLE.  For
-     *       example, suppose you round-robin on 2 Subchannels, in READY and CONNECTING states
-     *       respectively.  If the picker ignores the state and pick them equally, 50% of RPCs will
-     *       be stuck in buffered state until both Subchannels are READY.</li>
-     *   <li>This can also happen if you don't create a new picker at key state changes of
-     *       Subchannels.  Take the above round-robin example again.  Suppose you do pick only READY
-     *       and IDLE Subchannels, and initially both Subchannels are READY.  Now one becomes IDLE,
-     *       then CONNECTING and stays CONNECTING for a long time.  If you don't create a new picker
-     *       in response to the CONNECTING state to exclude that Subchannel, 50% of RPCs will hit it
-     *       and be buffered even though the other Subchannel is READY.</li>
-     * </ul>
-     *
-     * <p>In order to prevent unnecessary delay of RPCs, the rules of thumb are:
-     * <ol>
-     *   <li>The picker should only pick Subchannels that are known as READY or IDLE.  Whether to
-     *       pick IDLE Subchannels depends on whether you want Subchannels to connect on-demand or
-     *       actively:
-     *       <ul>
-     *         <li>If you want connect-on-demand, include IDLE Subchannels in your pick results,
-     *             because when an RPC tries to use an IDLE Subchannel, the Subchannel will try to
-     *             connect.</li>
-     *         <li>If you want Subchannels to be always connected even when there is no RPC, you
-     *             would call {@link Subchannel#requestConnection Subchannel.requestConnection()}
-     *             whenever the Subchannel has transitioned to IDLE, then you don't need to include
-     *             IDLE Subchannels in your pick results.</li>
-     *       </ul></li>
-     *   <li>Always create a new picker and call {@link Helper#updatePicker Helper.updatePicker()}
-     *       whenever {@link #handleSubchannelState handleSubchannelState()} is called, unless the
-     *       new state is SHUTDOWN. See {@code handleSubchannelState}'s javadoc for more
-     *       details.</li>
-     * </ol>
-     */
-    public static PickResult withSubchannel(Subchannel subchannel) {
-      return new PickResult(Preconditions.checkNotNull(subchannel, "subchannel"), Status.OK);
-    }
-
-    /**
-     * A decision to report a connectivity error to the RPC.  If the RPC is {@link
-     * CallOptions#withWaitForReady wait-for-ready}, it will stay buffered.  Otherwise, it will fail
-     * with the given error.
-     *
-     * @param error the error status.  Must not be OK.
-     */
-    public static PickResult withError(Status error) {
-      Preconditions.checkArgument(!error.isOk(), "error status shouldn't be OK");
-      return new PickResult(null, error);
-    }
-
-    /**
-     * No decision could be made.  The RPC will stay buffered.
-     */
-    public static PickResult withNoResult() {
-      return NO_RESULT;
-    }
-
-    /**
-     * The Subchannel if this result was created by {@link #withSubchannel withSubchannel()}, or
-     * null otherwise.
-     */
-    @Nullable
-    public Subchannel getSubchannel() {
-      return subchannel;
-    }
-
-    /**
-     * The status associated with this result.  Non-{@code OK} if created with {@link #withError
-     * withError}, or {@code OK} otherwise.
-     */
-    public Status getStatus() {
-      return status;
-    }
-
-    @Override
-    public String toString() {
-      return "[subchannel=" + subchannel + " status=" + status + "]";
-    }
-  }
-
-  /**
-   * Provides essentials for LoadBalancer implementations.
-   */
-  @ThreadSafe
-  public abstract static class Helper {
-    /**
-     * Creates a Subchannel, which is a logical connection to the given group of addresses which are
-     * considered equivalent.  The {@code attrs} are custom attributes associated with this
-     * Subchannel, and can be accessed later through {@link Subchannel#getAttributes
-     * Subchannel.getAttributes()}.
-     *
-     * <p>The LoadBalancer is responsible for closing unused Subchannels, and closing all
-     * Subchannels within {@link #shutdown}.
-     */
-    public abstract Subchannel createSubchannel(EquivalentAddressGroup addrs, Attributes attrs);
-
-    /**
-     * Out-of-band channel for LoadBalancer’s own RPC needs, e.g., talking to an external
-     * load-balancer service.
-     *
-     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
-     * channels within {@link #shutdown}.
-     */
-    public abstract ManagedChannel createOobChannel(
-        EquivalentAddressGroup eag, String authority);
-
-    /**
-     * Set a new picker to the channel.
-     *
-     * <p>When a new picker is provided via {@code updatePicker()}, the channel will apply the
-     * picker on all buffered RPCs, by calling {@link SubchannelPicker#pickSubchannel
-     * SubchannelPicker.pickSubchannel()}.
-     *
-     * <p>The channel will hold the picker and use it for all RPCs, until {@code updatePicker()} is
-     * called again and a new picker replaces the old one.  If {@code updatePicker()} has never been
-     * called, the channel will buffer all RPCs until a picker is provided.
-     */
-    public abstract void updatePicker(SubchannelPicker picker);
-
-    /**
-     * Schedule a task to be run in the Channel Executor, which serializes the task with the
-     * callback methods on the {@link LoadBalancer2} interface.
-     */
-    public abstract void runSerialized(Runnable task);
-
-    /**
-     * Returns the NameResolver of the channel.
-     */
-    public abstract NameResolver.Factory getNameResolverFactory();
-
-    /**
-     * Returns the authority string of the channel, which is derived from the DNS-style target name.
-     */
-    public abstract String getAuthority();
-  }
-
-  /**
-   * A logical connection to a server, or a group of equivalent servers represented by an {@link 
-   * EquivalentAddressGroup}.
-   *
-   * <p>It maintains at most one physical connection (aka transport) for sending new RPCs, while
-   * also keeps track of previous transports that has been shut down but not terminated yet.
-   *
-   * <p>If there isn't an active transport yet, and an RPC is assigned to the Subchannel, it will
-   * create a new transport.  It won't actively create transports otherwise.  {@link
-   * #requestConnection requestConnection()} can be used to ask Subchannel to create a transport if
-   * there isn't any.
-   */
-  @ThreadSafe
-  public abstract static class Subchannel {
-    /**
-     * Shuts down the Subchannel.  After this method is called, this Subchannel should no longer
-     * be returned by the latest {@link SubchannelPicker picker}, and can be safely discarded.
-     */
-    public abstract void shutdown();
-
-    /**
-     * Asks the Subchannel to create a connection (aka transport), if there isn't an active one.
-     */
-    public abstract void requestConnection();
-
-    /**
-     * Returns the addresses that this Subchannel is bound to.
-     */
-    public abstract EquivalentAddressGroup getAddresses();
-
-    /**
-     * The same attributes passed to {@link Helper#createSubchannel Helper.createSubchannel()}.
-     * LoadBalancer can use it to attach additional information here, e.g., the shard this
-     * Subchannel belongs to.
-     */
-    public abstract Attributes getAttributes();
-  }
-
-  @ThreadSafe
-  public abstract static class Factory {
-    /**
-     * Creates a {@link LoadBalancer2} that will be used inside a channel.
-     */
-    public abstract LoadBalancer2 newLoadBalancer(Helper helper);
-  }
+@Deprecated
+public abstract class LoadBalancer2 extends LoadBalancer {
 }
diff --git a/core/src/main/java/io/grpc/ManagedChannelBuilder.java b/core/src/main/java/io/grpc/ManagedChannelBuilder.java
index eb6734c..bd17459 100644
--- a/core/src/main/java/io/grpc/ManagedChannelBuilder.java
+++ b/core/src/main/java/io/grpc/ManagedChannelBuilder.java
@@ -155,9 +155,9 @@
   public abstract T nameResolverFactory(NameResolver.Factory resolverFactory);
 
   /**
-   * Provides a custom {@link LoadBalancer2.Factory} for the channel.
+   * Provides a custom {@link LoadBalancer.Factory} for the channel.
    *
-   * <p>If this method is not called, the builder will use {@link PickFirstBalancerFactory2}
+   * <p>If this method is not called, the builder will use {@link PickFirstBalancerFactory}
    * for the channel.
    *
    * <p>Calling this will make the channel to run the LBv2 code path. See <a
@@ -169,9 +169,7 @@
    * this method will throw.
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-  public T loadBalancerFactory(LoadBalancer2.Factory loadBalancerFactory) {
-    throw new UnsupportedOperationException("Not implemented by " + this.getClass().getName());
-  }
+  public abstract T loadBalancerFactory(LoadBalancer.Factory loadBalancerFactory);
 
   /**
    * Set the decompression registry for use in the channel.  This is an advanced API call and
diff --git a/core/src/main/java/io/grpc/PickFirstBalancerFactory2.java b/core/src/main/java/io/grpc/PickFirstBalancerFactory.java
similarity index 78%
rename from core/src/main/java/io/grpc/PickFirstBalancerFactory2.java
rename to core/src/main/java/io/grpc/PickFirstBalancerFactory.java
index 2ef0d44..0c46cdd 100644
--- a/core/src/main/java/io/grpc/PickFirstBalancerFactory2.java
+++ b/core/src/main/java/io/grpc/PickFirstBalancerFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2015, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -31,6 +31,7 @@
 
 package io.grpc;
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static io.grpc.ConnectivityState.SHUTDOWN;
 
 import com.google.common.annotations.VisibleForTesting;
@@ -39,44 +40,39 @@
 import java.util.List;
 
 /**
- * A {@link LoadBalancer2} that provides no load balancing mechanism over the
+ * A {@link LoadBalancer} that provides no load balancing mechanism over the
  * addresses from the {@link NameResolver}.  The channel's default behavior
  * (currently pick-first) is used for all addresses found.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code PickFirstBalancerFactory} during <a href="https://github.com/grpc/grpc-java/issues/2656"
- * target="_blank">the transition to LBv2</a>. You should use it only if you want to experiment the
- * LBv2 code path.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public final class PickFirstBalancerFactory2 extends LoadBalancer2.Factory {
+public final class PickFirstBalancerFactory extends LoadBalancer.Factory {
 
-  private static final PickFirstBalancerFactory2 INSTANCE = new PickFirstBalancerFactory2();
+  private static final PickFirstBalancerFactory INSTANCE = new PickFirstBalancerFactory();
 
-  private PickFirstBalancerFactory2() {
+  private PickFirstBalancerFactory() {
   }
 
-  public static PickFirstBalancerFactory2 getInstance() {
+  public static PickFirstBalancerFactory getInstance() {
     return INSTANCE;
   }
 
   @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
     return new PickFirstBalancer(helper);
   }
 
   @VisibleForTesting
-  static class PickFirstBalancer extends LoadBalancer2 {
+  static final class PickFirstBalancer extends LoadBalancer {
     private final Helper helper;
     private Subchannel subchannel;
 
-    public PickFirstBalancer(Helper helper) {
-      this.helper = helper;
+    PickFirstBalancer(Helper helper) {
+      this.helper = checkNotNull(helper, "helper");
     }
 
     @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> servers,
-        Attributes attributes) {
+    public void handleResolvedAddresses(
+        List<ResolvedServerInfoGroup> servers, Attributes attributes) {
       // Flatten servers list received from name resolver into single address group. This means that
       // as far as load balancer is concerned, there's virtually one single server with multiple
       // addresses so the connection will be created only for the first address (pick first).
@@ -123,7 +119,7 @@
           pickResult = PickResult.withError(stateInfo.getStatus());
           break;
         default:
-          throw new IllegalStateException();
+          throw new IllegalArgumentException("Unsupported state:" + currentState);
       }
 
       helper.updatePicker(new Picker(pickResult));
@@ -157,15 +153,15 @@
    * received in constructor.
    */
   @VisibleForTesting
-  static class Picker extends LoadBalancer2.SubchannelPicker {
-    private final LoadBalancer2.PickResult result;
+  static final class Picker extends LoadBalancer.SubchannelPicker {
+    private final LoadBalancer.PickResult result;
 
-    Picker(LoadBalancer2.PickResult result) {
-      this.result = result;
+    Picker(LoadBalancer.PickResult result) {
+      this.result = checkNotNull(result, "result");
     }
 
     @Override
-    public LoadBalancer2.PickResult pickSubchannel(Attributes affinity, Metadata headers) {
+    public LoadBalancer.PickResult pickSubchannel(Attributes affinity, Metadata headers) {
       return result;
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java b/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
index 7c3ba42..a403e26 100644
--- a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
+++ b/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
@@ -43,12 +43,12 @@
 import io.grpc.ClientInterceptor;
 import io.grpc.CompressorRegistry;
 import io.grpc.DecompressorRegistry;
-import io.grpc.LoadBalancer2;
+import io.grpc.LoadBalancer;
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.NameResolver;
 import io.grpc.NameResolverProvider;
-import io.grpc.PickFirstBalancerFactory2;
+import io.grpc.PickFirstBalancerFactory;
 import io.grpc.ResolvedServerInfo;
 import io.grpc.ResolvedServerInfoGroup;
 import java.net.SocketAddress;
@@ -108,7 +108,7 @@
   @Nullable
   private NameResolver.Factory nameResolverFactory;
 
-  private LoadBalancer2.Factory loadBalancerFactory;
+  private LoadBalancer.Factory loadBalancerFactory;
 
   @Nullable
   private DecompressorRegistry decompressorRegistry;
@@ -193,9 +193,9 @@
   }
 
   @Override
-  public final T loadBalancerFactory(LoadBalancer2.Factory loadBalancerFactory) {
+  public final T loadBalancerFactory(LoadBalancer.Factory loadBalancerFactory) {
     Preconditions.checkState(directServerAddress == null,
-        "directServerAddress is set (%s), which forbids the use of LoadBalancerFactory",
+        "directServerAddress is set (%s), which forbids the use of LoadBalancer.Factory",
         directServerAddress);
     this.loadBalancerFactory = loadBalancerFactory;
     return thisT();
@@ -231,7 +231,7 @@
     // We convert to the largest unit to avoid overflow
     if (unit.toDays(value) >= IDLE_MODE_MAX_TIMEOUT_DAYS) {
       // This disables idle mode
-      this.idleTimeoutMillis = ManagedChannelImpl2.IDLE_TIMEOUT_MILLIS_DISABLE;
+      this.idleTimeoutMillis = ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE;
     } else {
       this.idleTimeoutMillis = Math.max(unit.toMillis(value), IDLE_MODE_MIN_TIMEOUT_MILLIS);
     }
@@ -275,21 +275,25 @@
       // getResource(), then this shouldn't be a problem unless called on the UI thread.
       nameResolverFactory = NameResolverProvider.asFactory();
     }
-    return new ManagedChannelImpl2(
+    return new ManagedChannelImpl(
         target,
         // TODO(carl-mastrangelo): Allow clients to pass this in
         new ExponentialBackoffPolicy.Provider(),
         nameResolverFactory,
         getNameResolverParams(),
-        firstNonNull(loadBalancerFactory, PickFirstBalancerFactory2.getInstance()),
+        firstNonNull(loadBalancerFactory, PickFirstBalancerFactory.getInstance()),
         transportFactory,
         firstNonNull(decompressorRegistry, DecompressorRegistry.getDefaultInstance()),
         firstNonNull(compressorRegistry, CompressorRegistry.getDefaultInstance()),
         SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE),
         getExecutorPool(executor),
         SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR),
-        GrpcUtil.STOPWATCH_SUPPLIER, idleTimeoutMillis,
-        userAgent, interceptors, firstNonNull(statsFactory,
+        GrpcUtil.STOPWATCH_SUPPLIER,
+        idleTimeoutMillis,
+        userAgent,
+        interceptors,
+        firstNonNull(
+            statsFactory,
             firstNonNull(Stats.getStatsContextFactory(), NoopStatsContextFactory.INSTANCE)));
   }
 
diff --git a/core/src/main/java/io/grpc/internal/ChannelExecutor.java b/core/src/main/java/io/grpc/internal/ChannelExecutor.java
index 3bf549d..6ab8e3b 100644
--- a/core/src/main/java/io/grpc/internal/ChannelExecutor.java
+++ b/core/src/main/java/io/grpc/internal/ChannelExecutor.java
@@ -42,7 +42,7 @@
 
 /**
  * The thread-less Channel Executor used to run the state mutation logic in {@link
- * ManagedChannelImpl}, {@link InternalSubchannel} and {@link io.grpc.LoadBalancer2}s.
+ * ManagedChannelImpl}, {@link InternalSubchannel} and {@link io.grpc.LoadBalancer}s.
  *
  * <p>Tasks are queued until {@link #drain} is called.  Tasks are guaranteed to be run in the same
  * order as they are submitted.
diff --git a/core/src/main/java/io/grpc/internal/DelayedClientTransport2.java b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
similarity index 95%
rename from core/src/main/java/io/grpc/internal/DelayedClientTransport2.java
rename to core/src/main/java/io/grpc/internal/DelayedClientTransport.java
index 3318db8..aa91dae 100644
--- a/core/src/main/java/io/grpc/internal/DelayedClientTransport2.java
+++ b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
@@ -34,8 +34,8 @@
 import com.google.common.annotations.VisibleForTesting;
 import io.grpc.CallOptions;
 import io.grpc.Context;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
@@ -55,7 +55,7 @@
  * for that stream, at which point the ownership of the stream is transferred to the real transport,
  * thus the delayed transport stops owning the stream.
  */
-final class DelayedClientTransport2 implements ManagedClientTransport {
+final class DelayedClientTransport implements ManagedClientTransport {
   private final LogId lodId = LogId.allocate(getClass().getName());
 
   private final Object lock = new Object();
@@ -96,7 +96,7 @@
    * @param channelExecutor all listener callbacks of the delayed transport will be run from this
    *        ChannelExecutor.
    */
-  DelayedClientTransport2(Executor defaultAppExecutor, ChannelExecutor channelExecutor) {
+  DelayedClientTransport(Executor defaultAppExecutor, ChannelExecutor channelExecutor) {
     this.defaultAppExecutor = defaultAppExecutor;
     this.channelExecutor = channelExecutor;
   }
@@ -188,13 +188,16 @@
     return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
   }
 
-  // Caller must call channelExecutor.drain() outside of lock because this method may schedule
-  // tasks on channelExecutor
+  /**
+   * Caller must call {@code channelExecutor.drain()} outside of lock because this method may
+   * schedule tasks on channelExecutor.
+   */
   @GuardedBy("lock")
-  private PendingStream createPendingStream(MethodDescriptor<?, ?> method, Metadata headers,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-    PendingStream pendingStream = new PendingStream(method, headers, callOptions,
-        statsTraceCtx);
+  private PendingStream createPendingStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      StatsTraceContext statsTraceCtx) {
+    PendingStream pendingStream =
+        new PendingStream(method, headers, callOptions, statsTraceCtx);
     pendingStreams.add(pendingStream);
     if (pendingStreams.size() == 1) {
       channelExecutor.executeLater(reportTransportInUse);
diff --git a/core/src/main/java/io/grpc/internal/GrpcUtil.java b/core/src/main/java/io/grpc/internal/GrpcUtil.java
index c532fe2..385551e 100644
--- a/core/src/main/java/io/grpc/internal/GrpcUtil.java
+++ b/core/src/main/java/io/grpc/internal/GrpcUtil.java
@@ -40,8 +40,8 @@
 import com.google.common.base.Supplier;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.internal.SharedResourceHolder.Resource;
diff --git a/core/src/main/java/io/grpc/internal/InUseStateAggregator2.java b/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
similarity index 98%
rename from core/src/main/java/io/grpc/internal/InUseStateAggregator2.java
rename to core/src/main/java/io/grpc/internal/InUseStateAggregator.java
index 6333f36..9668e27 100644
--- a/core/src/main/java/io/grpc/internal/InUseStateAggregator2.java
+++ b/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
@@ -38,7 +38,7 @@
  * Aggregates the in-use state of a set of objects.
  */
 @NotThreadSafe
-abstract class InUseStateAggregator2<T> {
+abstract class InUseStateAggregator<T> {
 
   private final HashSet<T> inUseObjects = new HashSet<T>();
 
diff --git a/core/src/main/java/io/grpc/internal/InternalSubchannel.java b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
index d221803..1ec7f16 100644
--- a/core/src/main/java/io/grpc/internal/InternalSubchannel.java
+++ b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
@@ -118,8 +118,8 @@
       new ArrayList<ConnectionClientTransport>();
 
   // Must only be used from channelExecutor
-  private final InUseStateAggregator2<ConnectionClientTransport> inUseStateAggregator =
-      new InUseStateAggregator2<ConnectionClientTransport>() {
+  private final InUseStateAggregator<ConnectionClientTransport> inUseStateAggregator =
+      new InUseStateAggregator<ConnectionClientTransport>() {
         @Override
         void handleInUse() {
           callback.onInUse(InternalSubchannel.this);
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
similarity index 96%
rename from core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java
rename to core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
index 04b7474..bc75ea1 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
@@ -51,9 +51,9 @@
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.DecompressorRegistry;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -81,8 +81,8 @@
 
 /** A communication channel for making outgoing RPCs. */
 @ThreadSafe
-public final class ManagedChannelImpl2 extends ManagedChannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(ManagedChannelImpl2.class.getName());
+public final class ManagedChannelImpl extends ManagedChannel implements WithLogId {
+  private static final Logger log = Logger.getLogger(ManagedChannelImpl.class.getName());
 
   // Matching this pattern means the target string is a URI target or at least intended to be one.
   // A URI target must be an absolute hierarchical URI.
@@ -102,7 +102,7 @@
   private final String target;
   private final NameResolver.Factory nameResolverFactory;
   private final Attributes nameResolverParams;
-  private final LoadBalancer2.Factory loadBalancerFactory;
+  private final LoadBalancer.Factory loadBalancerFactory;
   private final ClientTransportFactory transportFactory;
   private final Executor executor;
   private final ObjectPool<? extends Executor> executorPool;
@@ -140,7 +140,7 @@
 
   // null when channel is in idle mode.  Must be assigned from channelExecutor.
   @Nullable
-  private LoadBalancer2 loadBalancer;
+  private LoadBalancer loadBalancer;
 
   // Must be assigned from channelExecutor.  null if channel is in idle mode.
   @Nullable
@@ -155,7 +155,7 @@
   private final Set<InternalSubchannel> oobChannels = new HashSet<InternalSubchannel>(1, .75f);
 
   // reprocess() must be run from channelExecutor
-  private final DelayedClientTransport2 delayedTransport;
+  private final DelayedClientTransport delayedTransport;
 
   // Shutdown states.
   //
@@ -234,8 +234,8 @@
 
   // Must be accessed from channelExecutor
   @VisibleForTesting
-  final InUseStateAggregator2<Object> inUseStateAggregator =
-      new InUseStateAggregator2<Object>() {
+  final InUseStateAggregator<Object> inUseStateAggregator =
+      new InUseStateAggregator<Object>() {
         @Override
         void handleInUse() {
           exitIdleMode();
@@ -381,9 +381,9 @@
     }
   };
 
-  ManagedChannelImpl2(String target, BackoffPolicy.Provider backoffPolicyProvider,
+  ManagedChannelImpl(String target, BackoffPolicy.Provider backoffPolicyProvider,
       NameResolver.Factory nameResolverFactory, Attributes nameResolverParams,
-      LoadBalancer2.Factory loadBalancerFactory, ClientTransportFactory transportFactory,
+      LoadBalancer.Factory loadBalancerFactory, ClientTransportFactory transportFactory,
       DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry,
       ObjectPool<ScheduledExecutorService> timerServicePool,
       ObjectPool<? extends Executor> executorPool, ObjectPool<? extends Executor> oobExecutorPool,
@@ -398,7 +398,7 @@
     this.executorPool = checkNotNull(executorPool, "executorPool");
     this.oobExecutorPool = checkNotNull(oobExecutorPool, "oobExecutorPool");
     this.executor = checkNotNull(executorPool.getObject(), "executor");
-    this.delayedTransport = new DelayedClientTransport2(this.executor, this.channelExecutor);
+    this.delayedTransport = new DelayedClientTransport(this.executor, this.channelExecutor);
     this.delayedTransport.start(delayedTransportListener);
     this.backoffPolicyProvider = backoffPolicyProvider;
     this.transportFactory =
@@ -473,7 +473,7 @@
    * cancelled.
    */
   @Override
-  public ManagedChannelImpl2 shutdown() {
+  public ManagedChannelImpl shutdown() {
     log.log(Level.FINE, "[{0}] shutdown() called", getLogId());
     if (!shutdown.compareAndSet(false, true)) {
       return this;
@@ -495,7 +495,7 @@
    * return {@code false} immediately after this method returns.
    */
   @Override
-  public ManagedChannelImpl2 shutdownNow() {
+  public ManagedChannelImpl shutdownNow() {
     log.log(Level.FINE, "[{0}] shutdownNow() called", getLogId());
     shutdown();
     delayedTransport.shutdownNow(SHUTDOWN_NOW_STATUS);
@@ -547,7 +547,7 @@
         CallOptions callOptions) {
       Executor executor = callOptions.getExecutor();
       if (executor == null) {
-        executor = ManagedChannelImpl2.this.executor;
+        executor = ManagedChannelImpl.this.executor;
       }
       StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
           method.getFullMethodName(), statsFactory, stopwatchSupplier);
@@ -588,8 +588,8 @@
     }
   }
 
-  private class LbHelperImpl extends LoadBalancer2.Helper {
-    LoadBalancer2 lb;
+  private class LbHelperImpl extends LoadBalancer.Helper {
+    LoadBalancer lb;
     final NameResolver nr;
 
     LbHelperImpl(NameResolver nr) {
@@ -702,7 +702,7 @@
 
     @Override
     public String getAuthority() {
-      return ManagedChannelImpl2.this.authority();
+      return ManagedChannelImpl.this.authority();
     }
 
     @Override
@@ -733,8 +733,8 @@
   }
 
   private class NameResolverListenerImpl implements NameResolver.Listener {
-    final LoadBalancer2 balancer;
-    final LoadBalancer2.Helper helper;
+    final LoadBalancer balancer;
+    final LoadBalancer.Helper helper;
 
     NameResolverListenerImpl(LbHelperImpl helperImpl) {
       this.balancer = helperImpl.lb;
diff --git a/core/src/main/java/io/grpc/internal/OobChannel.java b/core/src/main/java/io/grpc/internal/OobChannel.java
index 0dfdfed..996f0e9 100644
--- a/core/src/main/java/io/grpc/internal/OobChannel.java
+++ b/core/src/main/java/io/grpc/internal/OobChannel.java
@@ -41,9 +41,9 @@
 import io.grpc.ClientCall;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -58,7 +58,7 @@
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
- * A ManagedChannel backed by a single {@link InternalSubchannel} and used for {@link LoadBalancer2}
+ * A ManagedChannel backed by a single {@link InternalSubchannel} and used for {@link LoadBalancer}
  * to its own RPC needs.
  */
 @ThreadSafe
@@ -71,7 +71,7 @@
   private final LogId logId = LogId.allocate(getClass().getName());
   private final StatsContextFactory statsFactory;
   private final String authority;
-  private final DelayedClientTransport2 delayedTransport;
+  private final DelayedClientTransport delayedTransport;
   private final ObjectPool<? extends Executor> executorPool;
   private final Executor executor;
   private final ScheduledExecutorService deadlineCancellationExecutor;
@@ -100,7 +100,7 @@
     this.deadlineCancellationExecutor = checkNotNull(
         deadlineCancellationExecutor, "deadlineCancellationExecutor");
     this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
-    this.delayedTransport = new DelayedClientTransport2(executor, channelExecutor);
+    this.delayedTransport = new DelayedClientTransport(executor, channelExecutor);
     this.delayedTransport.start(new ManagedClientTransport.Listener() {
         @Override
         public void transportShutdown(Status s) {
diff --git a/core/src/main/java/io/grpc/internal/SubchannelImpl.java b/core/src/main/java/io/grpc/internal/SubchannelImpl.java
index c352187..1a966ae 100644
--- a/core/src/main/java/io/grpc/internal/SubchannelImpl.java
+++ b/core/src/main/java/io/grpc/internal/SubchannelImpl.java
@@ -31,14 +31,14 @@
 
 package io.grpc.internal;
 
-import io.grpc.LoadBalancer2;
+import io.grpc.LoadBalancer;
 import javax.annotation.Nullable;
 
 /**
  * The base interface of the Subchannels returned by {@link
- * io.grpc.LoadBalancer2.Helper#createSubchannel}.
+ * io.grpc.LoadBalancer.Helper#createSubchannel}.
  */
-abstract class SubchannelImpl extends LoadBalancer2.Subchannel {
+abstract class SubchannelImpl extends LoadBalancer.Subchannel {
   /**
    * Same as {@link InternalSubchannel#obtainActiveTransport}.
    */
diff --git a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java b/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java
similarity index 87%
rename from core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java
rename to core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java
index 072a531..20b36bb 100644
--- a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java
+++ b/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java
@@ -41,10 +41,10 @@
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.Metadata;
 import io.grpc.NameResolver;
 import io.grpc.ResolvedServerInfo;
@@ -64,35 +64,30 @@
 import javax.annotation.concurrent.GuardedBy;
 
 /**
- * A {@link LoadBalancer2} that provides round-robin load balancing mechanism over the
+ * A {@link LoadBalancer} that provides round-robin load balancing mechanism over the
  * addresses from the {@link NameResolver}.  The sub-lists received from the name resolver
  * are considered to be an {@link EquivalentAddressGroup} and each of these sub-lists is
  * what is then balanced across.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code RoundRobinLoadBalancerFactory} during the
- * <a href="https://github.com/grpc/grpc-java/issues/2656" target="_blank">transition to LBv2</a>.
- * You should use it only if you want to experiment the LBv2 code path.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public class RoundRobinLoadBalancerFactory2 extends LoadBalancer2.Factory {
-  private static final RoundRobinLoadBalancerFactory2 INSTANCE =
-      new RoundRobinLoadBalancerFactory2();
+public class RoundRobinLoadBalancerFactory extends LoadBalancer.Factory {
+  private static final RoundRobinLoadBalancerFactory INSTANCE =
+      new RoundRobinLoadBalancerFactory();
 
-  private RoundRobinLoadBalancerFactory2() {
+  private RoundRobinLoadBalancerFactory() {
   }
 
-  public static RoundRobinLoadBalancerFactory2 getInstance() {
+  public static RoundRobinLoadBalancerFactory getInstance() {
     return INSTANCE;
   }
 
   @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
     return new RoundRobinLoadBalancer(helper);
   }
 
   @VisibleForTesting
-  static class RoundRobinLoadBalancer extends LoadBalancer2 {
+  static class RoundRobinLoadBalancer extends LoadBalancer {
     private final Helper helper;
     private final Map<EquivalentAddressGroup, Subchannel> subchannels =
         new HashMap<EquivalentAddressGroup, Subchannel>();
@@ -101,13 +96,13 @@
     static final Attributes.Key<AtomicReference<ConnectivityStateInfo>> STATE_INFO =
         Attributes.Key.of("state-info");
 
-    public RoundRobinLoadBalancer(Helper helper) {
-      this.helper = helper;
+    RoundRobinLoadBalancer(Helper helper) {
+      this.helper = checkNotNull(helper, "helper");
     }
 
     @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> servers,
-        Attributes attributes) {
+    public void handleResolvedAddresses(
+        List<ResolvedServerInfoGroup> servers, Attributes attributes) {
       Set<EquivalentAddressGroup> currentAddrs = subchannels.keySet();
       Set<EquivalentAddressGroup> latestAddrs =
           resolvedServerInfoGroupToEquivalentAddressGroup(servers);
@@ -237,7 +232,7 @@
   }
 
   @VisibleForTesting
-  static class Picker extends SubchannelPicker {
+  static final class Picker extends SubchannelPicker {
     @Nullable
     private final Status status;
     private final List<Subchannel> list;
diff --git a/core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java b/core/src/test/java/io/grpc/PickFirstLoadBalancerTest.java
similarity index 96%
rename from core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java
rename to core/src/test/java/io/grpc/PickFirstLoadBalancerTest.java
index 541f6da..d8d1505 100644
--- a/core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java
+++ b/core/src/test/java/io/grpc/PickFirstLoadBalancerTest.java
@@ -44,11 +44,11 @@
 import static org.mockito.Mockito.when;
 
 import com.google.common.collect.Lists;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.PickFirstBalancerFactory2.PickFirstBalancer;
-import io.grpc.PickFirstBalancerFactory2.Picker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.PickFirstBalancerFactory.PickFirstBalancer;
+import io.grpc.PickFirstBalancerFactory.Picker;
 import java.net.SocketAddress;
 import java.util.List;
 import org.junit.Before;
@@ -62,9 +62,9 @@
 import org.mockito.MockitoAnnotations;
 
 
-/** Unit test for {@link PickFirstBalancerFactory2}. */
+/** Unit test for {@link PickFirstBalancerFactory}. */
 @RunWith(JUnit4.class)
-public class PickFirstLoadBalancer2Test {
+public class PickFirstLoadBalancerTest {
   private PickFirstBalancer loadBalancer;
   private List<ResolvedServerInfoGroup> servers = Lists.newArrayList();
   private List<SocketAddress> socketAddresses = Lists.newArrayList();
@@ -96,7 +96,7 @@
     when(mockHelper.createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class)))
         .thenReturn(mockSubchannel);
 
-    loadBalancer = (PickFirstBalancer) PickFirstBalancerFactory2.getInstance().newLoadBalancer(
+    loadBalancer = (PickFirstBalancer) PickFirstBalancerFactory.getInstance().newLoadBalancer(
         mockHelper);
   }
 
diff --git a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java b/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
index c825a5f..3413e77 100644
--- a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
@@ -78,11 +78,11 @@
         builder.getIdleTimeoutMillis());
 
     builder.idleTimeout(Long.MAX_VALUE, TimeUnit.DAYS);
-    assertEquals(ManagedChannelImpl2.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
+    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
 
     builder.idleTimeout(AbstractManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS,
         TimeUnit.DAYS);
-    assertEquals(ManagedChannelImpl2.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
+    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
 
     try {
       builder.idleTimeout(0, TimeUnit.SECONDS);
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
similarity index 98%
rename from core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java
rename to core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
index a2c503d..39f7aee 100644
--- a/core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java
+++ b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
@@ -51,8 +51,8 @@
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
 import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
@@ -76,10 +76,10 @@
 import org.mockito.stubbing.Answer;
 
 /**
- * Unit tests for {@link DelayedClientTransport2}.
+ * Unit tests for {@link DelayedClientTransport}.
  */
 @RunWith(JUnit4.class)
-public class DelayedClientTransport2Test {
+public class DelayedClientTransportTest {
   @Mock private ManagedClientTransport.Listener transportListener;
   @Mock private SubchannelPicker mockPicker;
   @Mock private SubchannelImpl mockSubchannel;
@@ -117,7 +117,7 @@
 
   private final FakeClock fakeExecutor = new FakeClock();
 
-  private final DelayedClientTransport2 delayedTransport = new DelayedClientTransport2(
+  private final DelayedClientTransport delayedTransport = new DelayedClientTransport(
       fakeExecutor.getScheduledExecutorService(), new ChannelExecutor());
 
   @Before public void setUp() {
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
index 3e57b62..cd6d599 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
@@ -43,7 +43,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Unit tests for {@link ManagedChannelImpl2#getNameResolver}. */
+/** Unit tests for {@link ManagedChannelImpl#getNameResolver}. */
 @RunWith(JUnit4.class)
 public class ManagedChannelImplGetNameResolverTest {
   private static final Attributes NAME_RESOLVER_PARAMS =
@@ -121,7 +121,7 @@
       }
     };
     try {
-      ManagedChannelImpl2.getNameResolver(
+      ManagedChannelImpl.getNameResolver(
           "foo.googleapis.com:8080", nameResolverFactory, NAME_RESOLVER_PARAMS);
       fail("Should fail");
     } catch (IllegalArgumentException e) {
@@ -131,7 +131,7 @@
 
   private void testValidTarget(String target, String expectedUriString, URI expectedUri) {
     Factory nameResolverFactory = new FakeNameResolverFactory(expectedUri.getScheme());
-    FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl2.getNameResolver(
+    FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
         target, nameResolverFactory, NAME_RESOLVER_PARAMS);
     assertNotNull(nameResolver);
     assertEquals(expectedUri, nameResolver.uri);
@@ -142,7 +142,7 @@
     Factory nameResolverFactory = new FakeNameResolverFactory("dns");
 
     try {
-      FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl2.getNameResolver(
+      FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
           target, nameResolverFactory, NAME_RESOLVER_PARAMS);
       fail("Should have failed, but got resolver with " + nameResolver.uri);
     } catch (IllegalArgumentException e) {
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
similarity index 96%
rename from core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java
rename to core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
index f3b64bb..d205038 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
@@ -52,11 +52,11 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -90,14 +90,14 @@
  * Unit tests for {@link ManagedChannelImpl}'s idle mode.
  */
 @RunWith(JUnit4.class)
-public class ManagedChannelImpl2IdlenessTest {
+public class ManagedChannelImplIdlenessTest {
   private final FakeClock timer = new FakeClock();
   private final FakeClock executor = new FakeClock();
   private final FakeClock oobExecutor = new FakeClock();
   private static final String AUTHORITY = "fakeauthority";
   private static final String USER_AGENT = "fakeagent";
   private static final long IDLE_TIMEOUT_SECONDS = 30;
-  private ManagedChannelImpl2 channel;
+  private ManagedChannelImpl channel;
 
   private final MethodDescriptor<String, Integer> method =
       MethodDescriptor.<String, Integer>newBuilder()
@@ -115,8 +115,8 @@
   @Mock private ObjectPool<Executor> executorPool;
   @Mock private ObjectPool<Executor> oobExecutorPool;
   @Mock private ClientTransportFactory mockTransportFactory;
-  @Mock private LoadBalancer2 mockLoadBalancer;
-  @Mock private LoadBalancer2.Factory mockLoadBalancerFactory;
+  @Mock private LoadBalancer mockLoadBalancer;
+  @Mock private LoadBalancer.Factory mockLoadBalancerFactory;
   @Mock private NameResolver mockNameResolver;
   @Mock private NameResolver.Factory mockNameResolverFactory;
   @Mock private ClientCall.Listener<Integer> mockCallListener;
@@ -136,7 +136,7 @@
         .newNameResolver(any(URI.class), any(Attributes.class)))
         .thenReturn(mockNameResolver);
 
-    channel = new ManagedChannelImpl2("fake://target", new FakeBackoffPolicyProvider(),
+    channel = new ManagedChannelImpl("fake://target", new FakeBackoffPolicyProvider(),
         mockNameResolverFactory, Attributes.EMPTY, mockLoadBalancerFactory,
         mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
         CompressorRegistry.getDefaultInstance(), timerServicePool, executorPool, oobExecutorPool,
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
similarity index 96%
rename from core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java
rename to core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
index af2586a..8bca0a4 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
@@ -71,11 +71,11 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -116,9 +116,9 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-/** Unit tests for {@link ManagedChannelImpl2}. */
+/** Unit tests for {@link ManagedChannelImpl}. */
 @RunWith(JUnit4.class)
-public class ManagedChannelImpl2Test {
+public class ManagedChannelImplTest {
   private static final List<ClientInterceptor> NO_INTERCEPTOR =
       Collections.<ClientInterceptor>emptyList();
   private static final Attributes NAME_RESOLVER_PARAMS =
@@ -147,16 +147,16 @@
 
   @Rule public final ExpectedException thrown = ExpectedException.none();
 
-  private ManagedChannelImpl2 channel;
+  private ManagedChannelImpl channel;
   private Helper helper;
   @Captor
   private ArgumentCaptor<Status> statusCaptor;
   @Captor
   private ArgumentCaptor<StatsTraceContext> statsTraceCtxCaptor;
   @Mock
-  private LoadBalancer2.Factory mockLoadBalancerFactory;
+  private LoadBalancer.Factory mockLoadBalancerFactory;
   @Mock
-  private LoadBalancer2 mockLoadBalancer;
+  private LoadBalancer mockLoadBalancer;
   @Captor
   private ArgumentCaptor<ConnectivityStateInfo> stateInfoCaptor;
   @Mock
@@ -188,11 +188,11 @@
 
   private void createChannel(
       NameResolver.Factory nameResolverFactory, List<ClientInterceptor> interceptors) {
-    channel = new ManagedChannelImpl2(target, new FakeBackoffPolicyProvider(),
+    channel = new ManagedChannelImpl(target, new FakeBackoffPolicyProvider(),
         nameResolverFactory, NAME_RESOLVER_PARAMS, mockLoadBalancerFactory,
         mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
         CompressorRegistry.getDefaultInstance(), timerServicePool, executorPool, oobExecutorPool,
-        timer.getStopwatchSupplier(),  ManagedChannelImpl2.IDLE_TIMEOUT_MILLIS_DISABLE, userAgent,
+        timer.getStopwatchSupplier(),  ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, userAgent,
         interceptors, statsCtxFactory);
     // Force-exit the initial idle-mode
     channel.exitIdleMode();
@@ -365,7 +365,7 @@
       assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
       // call should have been aborted by delayed transport
       executor.runDueTasks();
-      verify(mockCallListener).onClose(same(ManagedChannelImpl2.SHUTDOWN_NOW_STATUS),
+      verify(mockCallListener).onClose(same(ManagedChannelImpl.SHUTDOWN_NOW_STATUS),
           any(Metadata.class));
     } else {
       // LoadBalancer and NameResolver are still running.
@@ -389,7 +389,7 @@
 
     if (shutdownNow) {
       // Channel shutdownNow() all subchannels after shutting down LoadBalancer
-      verify(mockTransport).shutdownNow(ManagedChannelImpl2.SHUTDOWN_NOW_STATUS);
+      verify(mockTransport).shutdownNow(ManagedChannelImpl.SHUTDOWN_NOW_STATUS);
     } else {
       verify(mockTransport, never()).shutdownNow(any(Status.class));
     }
@@ -755,7 +755,7 @@
 
     // shutdown() has a delay
     sub1.shutdown();
-    timer.forwardTime(ManagedChannelImpl2.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS - 1, TimeUnit.SECONDS);
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS - 1, TimeUnit.SECONDS);
     sub1.shutdown();
     verify(transportInfo1.transport, never()).shutdown();
     timer.forwardTime(1, TimeUnit.SECONDS);
@@ -991,12 +991,12 @@
 
   @Test
   public void uriPattern() {
-    assertTrue(ManagedChannelImpl2.URI_PATTERN.matcher("a:/").matches());
-    assertTrue(ManagedChannelImpl2.URI_PATTERN.matcher("Z019+-.:/!@ #~ ").matches());
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("a/:").matches()); // "/:" not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("0a:/").matches()); // '0' not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("a,:/").matches()); // ',' not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher(" a:/").matches()); // space not matched
+    assertTrue(ManagedChannelImpl.URI_PATTERN.matcher("a:/").matches());
+    assertTrue(ManagedChannelImpl.URI_PATTERN.matcher("Z019+-.:/!@ #~ ").matches());
+    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("a/:").matches()); // "/:" not matched
+    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("0a:/").matches()); // '0' not matched
+    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("a,:/").matches()); // ',' not matched
+    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher(" a:/").matches()); // space not matched
   }
 
   /**
diff --git a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java b/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
similarity index 95%
rename from core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java
rename to core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
index fb28afa..d260919 100644
--- a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java
+++ b/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
@@ -34,7 +34,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
-import static io.grpc.util.RoundRobinLoadBalancerFactory2.RoundRobinLoadBalancer.STATE_INFO;
+import static io.grpc.util.RoundRobinLoadBalancerFactory.RoundRobinLoadBalancer.STATE_INFO;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.mockito.Matchers.any;
@@ -53,15 +53,15 @@
 import io.grpc.ConnectivityState;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.Subchannel;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
 import io.grpc.Metadata;
 import io.grpc.ResolvedServerInfo;
 import io.grpc.ResolvedServerInfoGroup;
 import io.grpc.Status;
-import io.grpc.util.RoundRobinLoadBalancerFactory2.Picker;
-import io.grpc.util.RoundRobinLoadBalancerFactory2.RoundRobinLoadBalancer;
+import io.grpc.util.RoundRobinLoadBalancerFactory.Picker;
+import io.grpc.util.RoundRobinLoadBalancerFactory.RoundRobinLoadBalancer;
 import java.net.SocketAddress;
 import java.util.Collections;
 import java.util.List;
@@ -79,9 +79,9 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-/** Unit test for {@link RoundRobinLoadBalancerFactory2}. */
+/** Unit test for {@link RoundRobinLoadBalancerFactory}. */
 @RunWith(JUnit4.class)
-public class RoundRobinLoadBalancer2Test {
+public class RoundRobinLoadBalancerTest {
   private RoundRobinLoadBalancer loadBalancer;
   private Map<ResolvedServerInfoGroup, EquivalentAddressGroup> servers = Maps.newHashMap();
   private Map<EquivalentAddressGroup, Subchannel> subchannels = Maps.newLinkedHashMap();
@@ -117,7 +117,7 @@
           }
         });
 
-    loadBalancer = (RoundRobinLoadBalancer) RoundRobinLoadBalancerFactory2.getInstance()
+    loadBalancer = (RoundRobinLoadBalancer) RoundRobinLoadBalancerFactory.getInstance()
         .newLoadBalancer(mockHelper);
   }
 
@@ -323,7 +323,7 @@
     Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
     loadBalancer.handleNameResolutionError(error);
     verify(mockHelper).updatePicker(pickerCaptor.capture());
-    LoadBalancer2.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
         new Metadata());
     assertNull(pickResult.getSubchannel());
     assertEquals(error, pickResult.getStatus());
@@ -341,12 +341,12 @@
         any(Attributes.class));
     verify(mockHelper, times(2)).updatePicker(pickerCaptor.capture());
 
-    LoadBalancer2.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
         new Metadata());
     assertEquals(readySubchannel, pickResult.getSubchannel());
     assertEquals(Status.OK.getCode(), pickResult.getStatus().getCode());
 
-    LoadBalancer2.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
+    LoadBalancer.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
         new Metadata());
     assertEquals(readySubchannel, pickResult2.getSubchannel());
     verifyNoMoreInteractions(mockHelper);
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
similarity index 97%
rename from grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java
rename to grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
index d3b9507..63fa54b 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
@@ -43,7 +43,7 @@
 import io.grpc.Attributes;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
+import io.grpc.LoadBalancer;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.ResolvedServerInfoGroup;
@@ -67,13 +67,13 @@
 import javax.annotation.Nullable;
 
 /**
- * A {@link LoadBalancer2} that uses the GRPCLB protocol.
+ * A {@link LoadBalancer} that uses the GRPCLB protocol.
  *
  * <p>Optionally, when requested by the naming system, will delegate the work to a local pick-first
  * or round-robin balancer.
  */
-class GrpclbLoadBalancer2 extends LoadBalancer2 implements WithLogId {
-  private static final Logger logger = Logger.getLogger(GrpclbLoadBalancer2.class.getName());
+class GrpclbLoadBalancer extends LoadBalancer implements WithLogId {
+  private static final Logger logger = Logger.getLogger(GrpclbLoadBalancer.class.getName());
 
   @VisibleForTesting
   static final SubchannelPicker BUFFER_PICKER = new SubchannelPicker() {
@@ -104,7 +104,7 @@
 
   // If not null, all work is delegated to it.
   @Nullable
-  private LoadBalancer2 delegate;
+  private LoadBalancer delegate;
   private LbPolicy lbPolicy;
 
   ///////////////////////////////////////////////////////////////////////////////
@@ -128,7 +128,7 @@
   // A null element indicate a simulated error for throttling purpose
   private List<EquivalentAddressGroup> roundRobinList = Collections.emptyList();
 
-  GrpclbLoadBalancer2(Helper helper, Factory pickFirstBalancerFactory,
+  GrpclbLoadBalancer(Helper helper, Factory pickFirstBalancerFactory,
       Factory roundRobinBalancerFactory) {
     this.helper = checkNotNull(helper, "helper");
     this.serviceName = checkNotNull(helper.getAuthority(), "helper returns null authority");
@@ -450,7 +450,7 @@
   }
 
   @VisibleForTesting
-  LoadBalancer2 getDelegate() {
+  LoadBalancer getDelegate() {
     return delegate;
   }
 
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java
similarity index 65%
rename from grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java
rename to grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java
index 3471265..8ac2ffe 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java
@@ -32,36 +32,32 @@
 package io.grpc.grpclb;
 
 import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer2;
-import io.grpc.PickFirstBalancerFactory2;
-import io.grpc.util.RoundRobinLoadBalancerFactory2;
+import io.grpc.LoadBalancer;
+import io.grpc.PickFirstBalancerFactory;
+import io.grpc.util.RoundRobinLoadBalancerFactory;
 
 /**
- * A factory for {@link LoadBalancer2}s that uses the GRPCLB protocol.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code GrpclbLoadBalancerFactory} during <a href="https://github.com/grpc/grpc-java/issues/2656">
- * transition to LBv2</a>. You should use it only if you want to experiment the LBv2 code path.
+ * A factory for {@link LoadBalancer}s that uses the GRPCLB protocol.
  *
  * <p><b>Experimental:</b>This only works with the GRPCLB load-balancer service, which is not
  * available yet. Right now it's only good for internal testing.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1782")
-public class GrpclbLoadBalancerFactory2 extends LoadBalancer2.Factory {
+public class GrpclbLoadBalancerFactory extends LoadBalancer.Factory {
 
-  private static final GrpclbLoadBalancerFactory2 instance = new GrpclbLoadBalancerFactory2();
+  private static final GrpclbLoadBalancerFactory instance = new GrpclbLoadBalancerFactory();
 
-  private GrpclbLoadBalancerFactory2() {
+  private GrpclbLoadBalancerFactory() {
   }
 
-  public static GrpclbLoadBalancerFactory2 getInstance() {
+  public static GrpclbLoadBalancerFactory getInstance() {
     return instance;
   }
 
   @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
-    return new GrpclbLoadBalancer2(
-        helper, PickFirstBalancerFactory2.getInstance(),
-        RoundRobinLoadBalancerFactory2.getInstance());
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new GrpclbLoadBalancer(
+        helper, PickFirstBalancerFactory.getInstance(),
+        RoundRobinLoadBalancerFactory.getInstance());
   }
 }
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
similarity index 96%
rename from grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java
rename to grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
index 28d25fd..a99e0db 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
@@ -62,11 +62,11 @@
 import io.grpc.CallOptions;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -76,8 +76,8 @@
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.grpclb.GrpclbConstants.LbPolicy;
-import io.grpc.grpclb.GrpclbLoadBalancer2.ErrorPicker;
-import io.grpc.grpclb.GrpclbLoadBalancer2.RoundRobinPicker;
+import io.grpc.grpclb.GrpclbLoadBalancer.ErrorPicker;
+import io.grpc.grpclb.GrpclbLoadBalancer.RoundRobinPicker;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.internal.SerializingExecutor;
@@ -105,9 +105,9 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-/** Unit tests for {@link GrpclbLoadBalancer2}. */
+/** Unit tests for {@link GrpclbLoadBalancer}. */
 @RunWith(JUnit4.class)
-public class GrpclbLoadBalancer2Test {
+public class GrpclbLoadBalancerTest {
   private static final Attributes.Key<String> RESOLUTION_ATTR =
       Attributes.Key.of("resolution-attr");
   private static final String SERVICE_AUTHORITY = "api.google.com";
@@ -159,14 +159,14 @@
       new SerializingExecutor(MoreExecutors.directExecutor());
   private final Metadata headers = new Metadata();
   @Mock
-  private LoadBalancer2.Factory pickFirstBalancerFactory;
+  private LoadBalancer.Factory pickFirstBalancerFactory;
   @Mock
-  private LoadBalancer2 pickFirstBalancer;
+  private LoadBalancer pickFirstBalancer;
   @Mock
-  private LoadBalancer2.Factory roundRobinBalancerFactory;
+  private LoadBalancer.Factory roundRobinBalancerFactory;
   @Mock
-  private LoadBalancer2 roundRobinBalancer;
-  private GrpclbLoadBalancer2 balancer;
+  private LoadBalancer roundRobinBalancer;
+  private GrpclbLoadBalancer balancer;
 
   @SuppressWarnings("unchecked")
   @Before
@@ -240,7 +240,7 @@
         }
       }).when(helper).runSerialized(any(Runnable.class));
     when(helper.getAuthority()).thenReturn(SERVICE_AUTHORITY);
-    balancer = new GrpclbLoadBalancer2(helper, pickFirstBalancerFactory, roundRobinBalancerFactory);
+    balancer = new GrpclbLoadBalancer(helper, pickFirstBalancerFactory, roundRobinBalancerFactory);
   }
 
   @After
@@ -290,7 +290,7 @@
   @Test
   public void bufferPicker() {
     assertEquals(PickResult.withNoResult(),
-        GrpclbLoadBalancer2.BUFFER_PICKER.pickSubchannel(Attributes.EMPTY, headers));
+        GrpclbLoadBalancer.BUFFER_PICKER.pickSubchannel(Attributes.EMPTY, headers));
   }
 
   @Test
@@ -553,11 +553,11 @@
     assertEquals(new EquivalentAddressGroup(backends1.get(1)), subchannel2.getAddresses());
 
     // Before any subchannel is READY, a buffer picker will be provided
-    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
+    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer.BUFFER_PICKER));
 
     deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
     deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
-    inOrder.verify(helper, times(2)).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
+    inOrder.verify(helper, times(2)).updatePicker(same(GrpclbLoadBalancer.BUFFER_PICKER));
 
     // Let subchannels be connected
     deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
@@ -724,7 +724,7 @@
         eq(new EquivalentAddressGroup(backends.get(0))), any(Attributes.class));
     inOrder.verify(helper).createSubchannel(
         eq(new EquivalentAddressGroup(backends.get(1))), any(Attributes.class));
-    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
+    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer.BUFFER_PICKER));
     inOrder.verifyNoMoreInteractions();
   }
 
@@ -806,7 +806,7 @@
       Subchannel subchannel = subchannels[i];
       if (subchannel == null) {
         assertSame("list[" + i + "] should be drop",
-            GrpclbLoadBalancer2.THROTTLED_RESULT, picker.list.get(i));
+            GrpclbLoadBalancer.THROTTLED_RESULT, picker.list.get(i));
       } else {
         assertEquals("list[" + i + "] should be Subchannel",
             subchannel, picker.list.get(i).getSubchannel());