Move //mojo/{public, edk} underneath //third_party

mojo/public/java/bindings/src/org/chromium/mojo/bindings/InterfaceWithClient.java

Index: mojo/public/java/bindings/src/org/chromium/mojo/bindings/InterfaceWithClient.java
diff --git a/mojo/public/java/bindings/src/org/chromium/mojo/bindings/InterfaceWithClient.java b/mojo/public/java/bindings/src/org/chromium/mojo/bindings/InterfaceWithClient.java
deleted file mode 100644
index f7d8afec8a24a8db70d64adade82a9b79a1001d5..0000000000000000000000000000000000000000
--- a/mojo/public/java/bindings/src/org/chromium/mojo/bindings/InterfaceWithClient.java
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package org.chromium.mojo.bindings;
-
-import org.chromium.mojo.system.Core;
-import org.chromium.mojo.system.MessagePipeHandle;
-import org.chromium.mojo.system.Pair;
-
-/**
- * Base class for mojo generated interfaces that have a client.
- *
- * @param <CI> the type of the client interface.
- */
-public interface InterfaceWithClient<CI extends Interface> extends Interface {
-
-    /**
-     * Proxy class for interfaces with a client.
-     */
-    interface Proxy<CI extends Interface> extends Interface.Proxy, InterfaceWithClient<CI> {
-    }
-
-    /**
-     * Base implementation of Proxy.
-     *
-     * @param <CI> the type of the client interface.
-     */
-    abstract class AbstractProxy<CI extends Interface> extends Interface.AbstractProxy
-            implements Proxy<CI> {
-
-        /**
-         * Constructor.
-         *
-         * @param core the Core implementation used to create pipes and access the async waiter.
-         * @param messageReceiver the message receiver to send message to.
-         */
-        public AbstractProxy(Core core, MessageReceiverWithResponder messageReceiver) {
-            super(core, messageReceiver);
-        }
-
-        /**
-         * @see InterfaceWithClient#setClient(Interface)
-         */
-        @Override
-        public void setClient(CI client) {
-            throw new UnsupportedOperationException(
-                    "Setting the client on a proxy is not supported");
-        }
-    }
-
-    /**
-     * Base manager implementation for interfaces that have a client.
-     *
-     * @param <I> the type of the interface the manager can handle.
-     * @param <P> the type of the proxy the manager can handle. To be noted, P always extends I.
-     * @param <CI> the type of the client interface.
-     */
-    abstract class Manager<I extends InterfaceWithClient<CI>, P extends Proxy<CI>,
-            CI extends Interface> extends Interface.Manager<I, P> {
-
-        /**
-         * @see Interface.Manager#bind(Interface, MessagePipeHandle)
-         */
-        @Override
-        public final void bind(I impl, MessagePipeHandle handle) {
-            Router router = new RouterImpl(handle);
-            super.bind(handle.getCore(), impl, router);
-            @SuppressWarnings("unchecked")
-            CI client = (CI) getClientManager().attachProxy(handle.getCore(), router);
-            impl.setClient(client);
-            router.start();
-        }
-
-        /**
-         * Returns a Proxy that will send messages to the given |handle|. This implies that the
-         * other end of the handle must be connected to an implementation of the interface. |client|
-         * is the implementation of the client interface.
-         */
-        public P attachProxy(MessagePipeHandle handle, CI client) {
-            Router router = new RouterImpl(handle);
-            DelegatingConnectionErrorHandler handlers = new DelegatingConnectionErrorHandler();
-            handlers.addConnectionErrorHandler(client);
-            router.setErrorHandler(handlers);
-            getClientManager().bind(handle.getCore(), client, router);
-            P proxy = super.attachProxy(handle.getCore(), router);
-            handlers.addConnectionErrorHandler(proxy);
-            router.start();
-            return proxy;
-        }
-
-        /**
-         * Constructs a new |InterfaceRequest| for the interface. This method returns a Pair where
-         * the first element is a proxy, and the second element is the request. The proxy can be
-         * used immediately.
-         *
-         * @param client the implementation of the client interface.
-         */
-        public final Pair<P, InterfaceRequest<I>> getInterfaceRequest(Core core, CI client) {
-            Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(null);
-            P proxy = attachProxy(handles.first, client);
-            return Pair.create(proxy, new InterfaceRequest<I>(handles.second));
-        }
-
-        /**
-         * Returns a manager for the client inetrafce.
-         */
-        protected abstract Interface.Manager<CI, ?> getClientManager();
-    }
-
-    /**
-     * Set the client implementation for this interface.
-     */
-    public void setClient(CI client);
-}