Rename some postmessage API to make it more meaningful.

android_webview/java/src/org/chromium/android_webview/MessagePort.java

 // Copyright 2015 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;
 
 import android.util.Log;
 
 /**
  * Represents the MessageChannel MessagePort object. Inspired from
@@ skipping 19 matching lines @@
  * application cannot use a transferred port to post messages. If a transferred port
  * receives messages, they will be queued. This state is not visible to embedder app.
  *
  * TODO(sgurun) implement queueing messages while a port is in transfer
  * TODO(sgurun) implement freeing resources in content/message_port_service when a port is
  * closed
  */
 public class MessagePort implements PostMessageSender.PostMessageSenderDelegate {
 
     /**
-     * The interface for message handler for receiving messages. Called on a background thread.
+     * The message event handler for receiving messages. Called on a background thread.
      */
-    public static interface MessageHandler {
-        void onMessage(String message);
+    public abstract static class WebEventHandler {
+        public abstract void onMessage(String message);
     };
 
     /**
      * A specialized PostMessageSender for message channel message port.
      */
     private static class MessagePortPostMessageSender extends PostMessageSender {
 
         private MessagePort mSender;
 
         public MessagePortPostMessageSender(MessagePort sender, AwMessagePortService service) {
             super(sender, service);
             mSender = sender;
         }
         @Override
         protected boolean senderIsReady() {
             return mSender.isReady();
         }
     }
 
     private static final String TAG = "MessagePort";
     private static final int PENDING = -1;
     private int mPortId = PENDING;
-    private MessageHandler mHandler;
+    private WebEventHandler mWebEventHandler;
     private AwMessagePortService mMessagePortService;
     private boolean mClosed;
     private boolean mTransferred;
     private MessagePortPostMessageSender mPostMessageSender;
 
     public MessagePort(AwMessagePortService messagePortService) {
         mMessagePortService = messagePortService;
         mPostMessageSender = new MessagePortPostMessageSender(this, mMessagePortService);
         mMessagePortService.addObserver(mPostMessageSender);
     }
@@ skipping 24 matching lines @@
     }
 
     public boolean isTransferred() {
         return mTransferred;
     }
 
     public void setTransferred() {
         mTransferred = true;
     }
 
-    public void setMessageHandler(MessageHandler handler) {
-        mHandler = handler;
+    public void setWebEventHandler(WebEventHandler webEventHandler) {
+        mWebEventHandler = webEventHandler;
     }
 
     public void onMessage(String message) {
         if (isClosed()) {
             Log.w(TAG, "Port [" + mPortId + "] received message in closed state");
             return;
         }
-        if (mHandler == null) {
+        if (mWebEventHandler == null) {
             Log.w(TAG, "No handler set for port [" + mPortId + "], dropping message " + message);
             return;
         }
-        mHandler.onMessage(message);
+        mWebEventHandler.onMessage(message);
     }
 
     public void postMessage(String message, MessagePort[] msgPorts) throws IllegalStateException {
         if (isClosed() || isTransferred()) {
             throw new IllegalStateException("Port is already closed or transferred");
         }
         if (msgPorts != null) {
             for (MessagePort port : msgPorts) {
                 if (port.portId() == mPortId) {
                     throw new IllegalStateException("Source port cannot be transferred");
                 }
             }
         }
         mPostMessageSender.postMessage(null, message, null, msgPorts);
     }
 
     @Override
     public void postMessageToWeb(String frameName, String message, String targetOrigin,
             int[] sentPortIds) {
         mMessagePortService.postMessage(mPortId, message, sentPortIds);
     }
 }