Move MessagePort implementation from android_webview to content

android_webview/javatests/src/org/chromium/android_webview/test/PostMessageTest.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.android_webview.test;
 
 import static org.chromium.base.test.util.ScalableTimeout.scaleTimeout;
 
 import android.os.Handler;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.webkit.JavascriptInterface;
 
 import org.chromium.android_webview.AwContents;
-import org.chromium.android_webview.AwMessagePort;
-import org.chromium.android_webview.AwMessagePortService;
 import org.chromium.android_webview.test.util.CommonResources;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.DisabledTest;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.RetryOnFailure;
+import org.chromium.content.browser.AppWebMessagePort;
+import org.chromium.content.browser.AppWebMessagePortService;
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnPageFinishedHelper;
 import org.chromium.net.test.util.TestWebServer;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 
 /**
  * The tests for content postMessage API.
@@ skipping 160 matching lines @@
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testTransferringSamePortTwiceViaPostMessageToFrameNotAllowed() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 // Retransfer the port. This should fail with an exception.
                 try {
                     mAwContents.postMessageToFrame(null, "2", mWebServer.getBaseUrl(),
-                            new AwMessagePort[]{channel[1]});
+                            new AppWebMessagePort[]{channel[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // There are two cases that put a port in a started state.
     // 1. posting a message
     // 2. setting an event handler.
     // A started port cannot return to "non-started" state. The four tests below verifies
     // these conditions for both conditions, using message ports and message channels.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testStartedPortCannotBeTransferredUsingPostMessageToFrame1() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channel[1].postMessage("1", null);
                 try {
                     mAwContents.postMessageToFrame(null, "2", mWebServer.getBaseUrl(),
-                            new AwMessagePort[]{channel[1]});
+                            new AppWebMessagePort[]{channel[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // see documentation in testStartedPortCannotBeTransferredUsingPostMessageToFrame1
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testStartedPortCannotBeTransferredUsingPostMessageToFrame2() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 // set a web event handler, this puts the port in a started state.
-                channel[1].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[1].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) { }
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) { }
                 }, null);
                 try {
                     mAwContents.postMessageToFrame(null, "2", mWebServer.getBaseUrl(),
-                            new AwMessagePort[]{channel[1]});
+                            new AppWebMessagePort[]{channel[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // see documentation in testStartedPortCannotBeTransferredUsingPostMessageToFrame1
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     @RetryOnFailure
     public void testStartedPortCannotBeTransferredUsingMessageChannel1() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel1 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel1 = mAwContents.createMessageChannel();
                 channel1[1].postMessage("1", null);
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
                 try {
-                    channel2[0].postMessage("2", new AwMessagePort[]{channel1[1]});
+                    channel2[0].postMessage("2", new AppWebMessagePort[]{channel1[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // see documentation in testStartedPortCannotBeTransferredUsingPostMessageToFrame1
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testStartedPortCannotBeTransferredUsingMessageChannel2() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel1 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel1 = mAwContents.createMessageChannel();
                 // set a web event handler, this puts the port in a started state.
-                channel1[1].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel1[1].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) { }
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) { }
                 }, null);
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
                 try {
-                    channel2[0].postMessage("1", new AwMessagePort[]{channel1[1]});
+                    channel2[0].postMessage("1", new AppWebMessagePort[]{channel1[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
 
     // channel[0] and channel[1] are entangled ports, establishing a channel. Verify
     // it is not allowed to transfer channel[0] on channel[0].postMessage.
     // TODO(sgurun) Note that the related case of posting channel[1] via
     // channel[0].postMessage does not throw a JS exception at present. We do not throw
     // an exception in this case either since the information of entangled port is not
     // available at the source port. We need a new mechanism to implement to prevent
     // this case.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testTransferringSourcePortViaMessageChannelNotAllowed() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 try {
-                    channel[0].postMessage("1", new AwMessagePort[]{channel[0]});
+                    channel[0].postMessage("1", new AppWebMessagePort[]{channel[0]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Verify a closed port cannot be transferred to a frame.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testSendClosedPortToFrameNotAllowed() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channel[1].close();
                 try {
                     mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                            new AwMessagePort[]{channel[1]});
+                            new AppWebMessagePort[]{channel[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Verify a closed port cannot be transferred to a port.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testSendClosedPortToPortNotAllowed() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel1 = mAwContents.createMessageChannel();
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel1 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
                 channel2[1].close();
                 try {
-                    channel1[0].postMessage("1", new AwMessagePort[]{channel2[1]});
+                    channel1[0].postMessage("1", new AppWebMessagePort[]{channel2[1]});
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Verify messages cannot be posted to closed ports.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostMessageToClosedPortNotAllowed() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channel[0].close();
                 try {
                     channel[0].postMessage("1", null);
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Verify messages posted before closing a port is received at the destination port.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testMessagesPostedBeforeClosingPortAreTransferred() throws Throwable {
         loadPage(TITLE_FROM_POSTMESSAGE_TO_CHANNEL);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 channel[0].postMessage("2", null);
                 channel[0].postMessage("3", null);
                 channel[0].close();
             }
         });
         expectTitle("23");
     }
 
     // Verify a transferred port using postmessagetoframe cannot be closed.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testClosingTransferredPortToFrameThrowsAnException() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 try {
                     channel[1].close();
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Verify a transferred port using postmessagetoframe cannot be closed.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testClosingTransferredPortToChannelThrowsAnException() throws Throwable {
         loadPage(TEST_PAGE);
         final CountDownLatch latch = new CountDownLatch(1);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel1 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel1 = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel1[1]});
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
-                channel1[0].postMessage("2", new AwMessagePort[]{channel2[0]});
+                        new AppWebMessagePort[]{channel1[1]});
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
+                channel1[0].postMessage("2", new AppWebMessagePort[]{channel2[0]});
                 try {
                     channel2[0].close();
                 } catch (IllegalStateException ex) {
                     latch.countDown();
                     return;
                 }
                 fail();
             }
         });
         boolean ignore = latch.await(TIMEOUT, java.util.concurrent.TimeUnit.MILLISECONDS);
     }
 
     // Create two message channels, and while they are in pending state, transfer the
     // second one in the first one.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPendingPortCanBeTransferredInPendingPort() throws Throwable {
         loadPage(TITLE_FROM_POSTMESSAGE_TO_CHANNEL);
         final TestMessagePort testPort =
                 new TestMessagePort(getAwBrowserContext().getMessagePortService());
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel1 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel1 = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel1[1]});
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
-                channel1[0].postMessage("2", new AwMessagePort[]{channel2[0]});
+                        new AppWebMessagePort[]{channel1[1]});
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
+                channel1[0].postMessage("2", new AppWebMessagePort[]{channel2[0]});
             }
         });
         expectTitle("2");
     }
 
     private static class ChannelContainer {
         private boolean mReady;
-        private AwMessagePort[] mChannel;
+        private AppWebMessagePort[] mChannel;
         private final Object mLock = new Object();
         private String mMessage = "";
         private int mCount;
         private int mWaitCount;
 
         public ChannelContainer() {
             this(1);
         }
 
         public ChannelContainer(int n) {
             mWaitCount = n;
         }
 
-        public void set(AwMessagePort[] channel) {
+        public void set(AppWebMessagePort[] channel) {
             mChannel = channel;
         }
-        public AwMessagePort[] get() {
+        public AppWebMessagePort[] get() {
             return mChannel;
         }
 
         public void setMessage(String message) {
             synchronized (mLock) {
                 mMessage += message;
                 if (++mCount < mWaitCount) return;
                 mReady = true;
                 mLock.notify();
             }
@@ skipping 26 matching lines @@
     // to browser to block waiting for UI thread, and this would in turn block renderer
     // doing the conversion.
     @DisabledTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testReceiveMessageInBackgroundThread() throws Throwable {
         loadPage(TEST_PAGE);
         final ChannelContainer channelContainer = new ChannelContainer();
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 // verify communication from JS to Java.
                 channelContainer.set(channel);
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
             }
         });
         mMessageObject.waitForMessage();
         assertEquals(WEBVIEW_MESSAGE, mMessageObject.getData());
         assertEquals(SOURCE_ORIGIN, mMessageObject.getOrigin());
         // verify that one message port is received at the js side
         assertEquals(1, mMessageObject.getPorts().length);
         // wait until we receive a message from JS
         runTestOnUiThread(new Runnable() {
             @Override
@@ skipping 13 matching lines @@
             + "    <script>"
             + "        onmessage = function (e) {"
             + "            var myPort = e.ports[0];"
             + "            myPort.onmessage = function(e) {"
             + "                myPort.postMessage(e.data + \"" + JS_MESSAGE + "\"); }"
             + "        }"
             + "   </script>"
             + "</body></html>";
 
     // Call on non-UI thread.
-    private void waitUntilPortReady(final AwMessagePort port) throws Throwable {
+    private void waitUntilPortReady(final AppWebMessagePort port) throws Throwable {
         CriteriaHelper.pollUiThread(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 return port.isReady();
             }
         });
     }
 
     private static final String HELLO = "HELLO";
 
     // Message channels are created on UI thread in a pending state. They are
     // initialized at a later stage. Verify that a message port that is initialized
     // can be transferred to JS and full communication can happen on it.
     // Do this by sending a message to JS and let it echo'ing the message with
     // some text prepended to it.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testMessageChannelUsingInitializedPort() throws Throwable {
         final ChannelContainer channelContainer = new ChannelContainer();
         loadPage(ECHO_PAGE);
-        final AwMessagePort[] channel = ThreadUtils.runOnUiThreadBlocking(
-                new Callable<AwMessagePort[]>() {
+        final AppWebMessagePort[] channel = ThreadUtils.runOnUiThreadBlocking(
+                new Callable<AppWebMessagePort[]>() {
                     @Override
-                    public AwMessagePort[] call() {
+                    public AppWebMessagePort[] call() {
                         return mAwContents.createMessageChannel();
                     }
                 });
 
         waitUntilPortReady(channel[0]);
         waitUntilPortReady(channel[1]);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 channel[0].postMessage(HELLO, null);
             }
         });
         // wait for the asynchronous response from JS
         channelContainer.waitForMessage();
         assertEquals(HELLO + JS_MESSAGE, channelContainer.getMessage());
     }
 
     // Verify that a message port can be used immediately (even if it is in
     // pending state) after creation. In particular make sure the message port can be
     // transferred to JS and full communication can happen on it.
     // Do this by sending a message to JS and let it echo'ing the message with
     // some text prepended to it.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testMessageChannelUsingPendingPort() throws Throwable {
         final ChannelContainer channelContainer = new ChannelContainer();
         loadPage(ECHO_PAGE);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 channel[0].postMessage(HELLO, null);
             }
         });
         // Wait for the asynchronous response from JS.
         channelContainer.waitForMessage();
         assertEquals(HELLO + JS_MESSAGE, channelContainer.getMessage());
     }
 
     // Verify that a message port can be used for message transfer when both
     // ports are owned by same Webview.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testMessageChannelCommunicationWithinWebView() throws Throwable {
         final ChannelContainer channelContainer = new ChannelContainer();
         loadPage(ECHO_PAGE);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
-                channel[1].setMessageCallback(new AwMessagePort.MessageCallback() {
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
+                channel[1].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 channel[0].postMessage(HELLO, null);
             }
         });
         // Wait for the asynchronous response from JS.
         channelContainer.waitForMessage();
         assertEquals(HELLO, channelContainer.getMessage());
     }
 
     // Post a message with a pending port to a frame and then post a bunch of messages
     // after that. Make sure that they are not ordered at the receiver side.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostMessageToFrameNotReordersMessages() throws Throwable {
         loadPage(TITLE_FROM_POSTMESSAGE_TO_FRAME);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 mAwContents.postMessageToFrame(null, "2", mWebServer.getBaseUrl(), null);
                 mAwContents.postMessageToFrame(null, "3", mWebServer.getBaseUrl(), null);
             }
         });
         expectTitle("123");
     }
 
     private static final String RECEIVE_JS_MESSAGE_CHANNEL_PAGE =
             "<!DOCTYPE html><html><body>"
             + "    <script>"
@@ skipping 18 matching lines @@
     // 3. Java sends a message using the new channel in 2.
     // 4. Js responds to this message using the channel in 2.
     // 5. Java responds to message in 4 using the channel in 2.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testCanUseReceivedAwMessagePortFromJS() throws Throwable {
         loadPage(RECEIVE_JS_MESSAGE_CHANNEL_PAGE);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                        new AppWebMessagePort[]{channel[1]});
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, final AwMessagePort[] p) {
-                        p[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                    public void onMessage(String message, final AppWebMessagePort[] p) {
+                        p[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                             @Override
-                            public void onMessage(String message, AwMessagePort[] q) {
+                            public void onMessage(String message, AppWebMessagePort[] q) {
                                 assertEquals("3", message);
                                 p[0].postMessage("4", null);
                             }
                         }, null);
                         p[0].postMessage("2", null);
                     }
                 }, null);
             }
         });
         expectTitle("24");
     }
 
-    private static class TestMessagePort extends AwMessagePort {
+    private static class TestMessagePort extends AppWebMessagePort {
 
         private boolean mReady;
-        private AwMessagePort mPort;
+        private AppWebMessagePort mPort;
         private final Object mLock = new Object();
 
-        public TestMessagePort(AwMessagePortService service) {
+        public TestMessagePort(AppWebMessagePortService service) {
             super(service);
         }
 
-        public void setMessagePort(AwMessagePort port) {
+        public void setMessagePort(AppWebMessagePort port) {
             mPort = port;
         }
 
         public void setReady(boolean ready) {
             synchronized (mLock) {
                 mReady = ready;
             }
         }
         @Override
         public boolean isReady() {
@@ skipping 15 matching lines @@
         }
         @Override
         public boolean isClosed() {
             return mPort.isClosed();
         }
         @Override
         public void setMessageCallback(MessageCallback messageCallback, Handler handler) {
             mPort.setMessageCallback(messageCallback, handler);
         }
         @Override
-        public void onMessage(String message, AwMessagePort[] sentPorts) {
+        public void onMessage(String message, AppWebMessagePort[] sentPorts) {
             mPort.onMessage(message, sentPorts);
         }
         @Override
-        public void postMessage(String message, AwMessagePort[] sentPorts) throws
+        public void postMessage(String message, AppWebMessagePort[] sentPorts) throws
                 IllegalStateException {
             mPort.postMessage(message, sentPorts);
         }
     }
 
     // Post a message with a pending port to a frame and then post a message that
     // is pending after that. Make sure that when first message becomes ready,
     // the subsequent not-ready message is not sent.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostMessageToFrameNotSendsPendingMessages() throws Throwable {
         loadPage(TITLE_FROM_POSTMESSAGE_TO_FRAME);
         final TestMessagePort testPort =
                 new TestMessagePort(getAwBrowserContext().getMessagePortService());
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, "1", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[1]});
+                        new AppWebMessagePort[]{channel[1]});
                 mAwContents.postMessageToFrame(null, "2", mWebServer.getBaseUrl(), null);
-                AwMessagePort[] channel2 = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel2 = mAwContents.createMessageChannel();
                 // Test port is in a pending state so it should not be transferred.
                 testPort.setMessagePort(channel2[0]);
                 mAwContents.postMessageToFrame(null, "3", mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{testPort});
+                        new AppWebMessagePort[]{testPort});
             }
         });
         expectTitle("12");
     }
 
     private static final String WORKER_MESSAGE = "from_worker";
 
     // Listen for messages. Pass port 1 to worker and use port 2 to receive messages from
     // from worker.
     private static final String TEST_PAGE_FOR_PORT_TRANSFER =
@@ skipping 29 matching lines @@
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     @RetryOnFailure
     public void testTransferPortsToWorker() throws Throwable {
         mWebServer.setResponse("/worker.js", WORKER_SCRIPT,
                 CommonResources.getTextJavascriptHeaders(true));
         loadPage(TEST_PAGE_FOR_PORT_TRANSFER);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[]{channel[0], channel[1]});
+                        new AppWebMessagePort[]{channel[0], channel[1]});
             }
         });
         mMessageObject.waitForMessage();
         assertEquals(WORKER_MESSAGE, mMessageObject.getData());
     }
 
     private static final String POPUP_MESSAGE = "from_popup";
     private static final String POPUP_URL = "/popup.html";
     private static final String IFRAME_URL = "/iframe.html";
     private static final String MAIN_PAGE_FOR_POPUP_TEST = "<!DOCTYPE html><html>"
@@ skipping 25 matching lines @@
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostMessageToPopup() throws Throwable {
         triggerPopup(mAwContents, mContentsClient, mWebServer, MAIN_PAGE_FOR_POPUP_TEST, ECHO_PAGE,
                 POPUP_URL, "createPopup()");
         connectPendingPopup(mAwContents);
         final ChannelContainer channelContainer = new ChannelContainer();
 
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channelContainer.set(channel);
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[] {channel[1]});
+                        new AppWebMessagePort[] {channel[1]});
                 channel[0].postMessage(HELLO, null);
             }
         });
         channelContainer.waitForMessage();
         assertEquals(HELLO + JS_MESSAGE, channelContainer.getMessage());
     }
 
     // Test if WebView can post a message from/to an iframe in a popup window.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostMessageToIframeInsidePopup() throws Throwable {
         mWebServer.setResponse(IFRAME_URL, ECHO_PAGE, null);
         triggerPopup(mAwContents, mContentsClient, mWebServer, MAIN_PAGE_FOR_POPUP_TEST,
                 POPUP_PAGE_WITH_IFRAME, POPUP_URL, "createPopup()");
         connectPendingPopup(mAwContents);
         final ChannelContainer channelContainer = new ChannelContainer();
 
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channelContainer.set(channel);
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[] {channel[1]});
+                        new AppWebMessagePort[] {channel[1]});
                 channel[0].postMessage(HELLO, null);
             }
         });
         channelContainer.waitForMessage();
         assertEquals(HELLO + JS_MESSAGE, channelContainer.getMessage());
     }
 
     private static final String TEST_PAGE_FOR_UNSUPPORTED_MESSAGES = "<!DOCTYPE html><html><body>"
             + "    <script>"
             + "        onmessage = function (e) {"
@@ skipping 11 matching lines @@
 
     // Make sure that postmessage can handle unsupported messages gracefully.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testPostUnsupportedWebMessageToApp() throws Throwable {
         loadPage(TEST_PAGE_FOR_UNSUPPORTED_MESSAGES);
         final ChannelContainer channelContainer = new ChannelContainer();
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channelContainer.set(channel);
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[] {channel[1]});
+                        new AppWebMessagePort[] {channel[1]});
             }
         });
         channelContainer.waitForMessage();
         assertEquals(JS_MESSAGE, channelContainer.getMessage());
         // Assert that onMessage is called only once.
         assertEquals(1, channelContainer.getMessageCount());
     }
 
     private static final String TEST_TRANSFER_EMPTY_PORTS = "<!DOCTYPE html><html><body>"
             + "    <script>"
             + "        onmessage = function (e) {"
             + "            e.ports[0].postMessage('1', undefined);"
             + "            e.ports[0].postMessage('2', []);"
             + "        }"
             + "   </script>"
             + "</body></html>";
 
     // Make sure that postmessage can handle unsupported messages gracefully.
     @SmallTest
     @Feature({"AndroidWebView", "Android-PostMessage"})
     public void testTransferEmptyPortsArray() throws Throwable {
         loadPage(TEST_TRANSFER_EMPTY_PORTS);
         final ChannelContainer channelContainer = new ChannelContainer(2);
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
-                AwMessagePort[] channel = mAwContents.createMessageChannel();
+                AppWebMessagePort[] channel = mAwContents.createMessageChannel();
                 channelContainer.set(channel);
-                channel[0].setMessageCallback(new AwMessagePort.MessageCallback() {
+                channel[0].setMessageCallback(new AppWebMessagePort.MessageCallback() {
                     @Override
-                    public void onMessage(String message, AwMessagePort[] sentPorts) {
+                    public void onMessage(String message, AppWebMessagePort[] sentPorts) {
                         channelContainer.setMessage(message);
                     }
                 }, null);
                 mAwContents.postMessageToFrame(null, WEBVIEW_MESSAGE, mWebServer.getBaseUrl(),
-                        new AwMessagePort[] {channel[1]});
+                        new AppWebMessagePort[] {channel[1]});
             }
         });
         channelContainer.waitForMessage();
         assertEquals("12", channelContainer.getMessage());
     }
 }