HTML MessagePort as mojo::MessagePipeHandle

content/public/android/java/src/org/chromium/content/browser/AppWebMessagePort.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.content.browser;
 
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 
 import org.chromium.base.Log;
+import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.annotations.JNINamespace;
 import org.chromium.content_public.browser.MessagePort;
 
 import java.util.Arrays;
 
 /**
  * Represents the MessageChannel MessagePort object. Inspired from
  * http://www.whatwg.org/specs/web-apps/current-work/multipage/web-messaging.html#message-channels
  *
  * State management:
  *
@@ skipping 44 matching lines @@
  * A port is put to a "started" state if:
  * 1. The port is ever used to post a message, or
  * 2. The port was ever registered a handler to receive a message.
  * A started port cannot be transferred.
  *
  * This restriction should not impact postmessage functionality in a big way,
  * because an app can still create as many channels as it wants to and use it for
  * transferring data. As a return, it simplifies implementation and prevents hard
  * to debug, racy corner cases while receiving/sending data.
  */
-public class AppWebMessagePort implements MessagePort, PostMessageSender.PostMessageSenderDelegate {
-    private static final String TAG = "MessagePort";
-    private static final int PENDING = -1;
+@JNINamespace("content")
+public class AppWebMessagePort implements MessagePort {
+    private static final String TAG = "AppWebMessagePort";
+    private static final long UNINITIALIZED_PORT_NATIVE_PTR = 0;
 
-    // the what value for POST_MESSAGE
-    private static final int POST_MESSAGE = 1;
-
-    private static class PostMessageFromWeb {
-        public AppWebMessagePort port;
-        public String message;
-        public AppWebMessagePort[] sentPorts;
-
-        public PostMessageFromWeb(
-                AppWebMessagePort port, String message, AppWebMessagePort[] sentPorts) {
-            this.port = port;
-            this.message = message;
-            this.sentPorts = sentPorts;
-        }
-    }
+    // The |what| value for handleMessage.
+    private static final int MESSAGES_AVAILABLE = 1;
 
     // Implements the handler to handle messageport messages received from web.
     // These messages are received on IO thread and normally handled in main
     // thread however, alternatively application can pass a handler to execute them.
     private static class MessageHandler extends Handler {
         public MessageHandler(Looper looper) {
             super(looper);
         }
         @Override
         public void handleMessage(Message msg) {
-            if (msg.what == POST_MESSAGE) {
-                PostMessageFromWeb m = (PostMessageFromWeb) msg.obj;
-                m.port.onMessage(m.message, m.sentPorts);
+            if (msg.what == MESSAGES_AVAILABLE) {
+                AppWebMessagePort port = (AppWebMessagePort) msg.obj;
+                port.dispatchReceivedMessages();
                 return;
             }
             throw new IllegalStateException("undefined message");
         }
     }
     // The default message handler
     private static final MessageHandler sDefaultHandler =
             new MessageHandler(Looper.getMainLooper());
 
-    private int mPortId = PENDING;
+    private long mNativeAppWebMessagePort = UNINITIALIZED_PORT_NATIVE_PTR;
+
     private MessageCallback mMessageCallback;
-    private AppWebMessagePortService mMessagePortService;
     private boolean mClosed;
     private boolean mTransferred;
     private boolean mStarted;
-    private boolean mReleasedMessages;
-    private PostMessageSender mPostMessageSender;
     private MessageHandler mHandler;
     private final Object mLock = new Object();
 
-    public AppWebMessagePort(AppWebMessagePortService messagePortService) {
-        mMessagePortService = messagePortService;
-        mPostMessageSender = new PostMessageSender(this, mMessagePortService);
-        mMessagePortService.addObserver(mPostMessageSender);
+    // Called to create an entangled pair of ports.
+    public static AppWebMessagePort[] createPair() {
+        AppWebMessagePort[] ports =
+            new AppWebMessagePort[] { new AppWebMessagePort(), new AppWebMessagePort() };
+        nativeInitializeAppWebMessagePortPair(ports);
+        return ports;
     }
 
     @Override
     public boolean isReady() {
-        return mPortId != PENDING;
+        return mNativeAppWebMessagePort != UNINITIALIZED_PORT_NATIVE_PTR;
     }
 
-    public int portId() {
-        return mPortId;
+    @CalledByNative
+    private void setNativeAppWebMessagePort(long nativeAppWebMessagePort) {
+        mNativeAppWebMessagePort = nativeAppWebMessagePort;
     }
 
-    public void setPortId(int id) {
-        mPortId = id;
-        releaseMessages();
+    @CalledByNative
+    private long releaseNativePortForTransfer() {

[sgurun-gerrit only, 2017/02/08 21:47:50]

who is deleting the native message port after it is transferred? unless is
triggering closemessageport() (which I don't see), we are leaking them.

[darin (slow to review), 2017/02/09 00:13:17]

Thanks, I need to delete the native side from
AppWebMessagePort::UnwrapJavaArray. Presently, I am just leaking it. Good catch!

+        mTransferred = true;
+        long port = mNativeAppWebMessagePort;
+        mNativeAppWebMessagePort = UNINITIALIZED_PORT_NATIVE_PTR;
+        return port;
     }
 
     @Override
     public void close() {
         if (mTransferred) {
             throw new IllegalStateException("Port is already transferred");
         }
         synchronized (mLock) {
             if (mClosed) return;
             mClosed = true;
         }
-        // If the port is already ready, and no messages are waiting in the
-        // queue to be transferred, onPostMessageQueueEmpty() callback is not
-        // received (it is received only after messages are purged). In this
-        // case do the cleanup here.
-        if (isReady() && mPostMessageSender.isMessageQueueEmpty()) {
+        if (isReady()) {
             cleanup();
         }
     }
 
     @Override
     public boolean isClosed() {
-        return mClosed;
+        synchronized (mLock) {
+            return mClosed;
+        }
     }
 
     @Override
     public boolean isTransferred() {
         return mTransferred;
     }
 
-    public void setTransferred() {
-        mTransferred = true;
-    }
-
     @Override
     public boolean isStarted() {
         return mStarted;
     }
 
     // Only called on UI thread
     @Override
     public void setMessageCallback(MessageCallback messageCallback, Handler handler) {
         mStarted = true;
         synchronized (mLock) {
             mMessageCallback = messageCallback;
             if (handler != null) {
                 mHandler = new MessageHandler(handler.getLooper());
             }
         }
-        releaseMessages();
+        nativeStartReceivingMessages(mNativeAppWebMessagePort);
     }
 
-    // Only called on IO thread.
-    public void onReceivedMessage(String message, AppWebMessagePort[] sentPorts) {
+    // Called on a background thread.
+    @CalledByNative
+    private void onMessagesAvailable() {
         synchronized (mLock) {
-            PostMessageFromWeb m = new PostMessageFromWeb(this, message, sentPorts);
             Handler handler = mHandler != null ? mHandler : sDefaultHandler;
-            Message msg = handler.obtainMessage(POST_MESSAGE, m);
+            Message msg = handler.obtainMessage(MESSAGES_AVAILABLE, this);
             handler.sendMessage(msg);
         }
     }
 
-    private void releaseMessages() {
-        if (mReleasedMessages || !isReady() || mMessageCallback == null) {
-            return;
-        }
-        mReleasedMessages = true;
-        mMessagePortService.releaseMessages(mPortId);
-    }
-
     // This method may be called on a different thread than UI thread.
-    public void onMessage(String message, AppWebMessagePort[] ports) {
+    @CalledByNative
+    private void onReceivedMessage(String message, AppWebMessagePort[] ports) {
         synchronized (mLock) {
             if (isClosed()) {
-                Log.w(TAG, "Port [" + mPortId + "] received message in closed state");
+                Log.w(TAG, "Port [" + mNativeAppWebMessagePort
+                        + "] received message in closed state");
                 return;
             }
             if (mMessageCallback == null) {
-                Log.w(TAG,
-                        "No handler set for port [" + mPortId + "], dropping message " + message);
+                Log.w(TAG, "No handler set for port [" + mNativeAppWebMessagePort
+                        + "], dropping message " + message);
                 return;
             }
             mMessageCallback.onMessage(message, ports);
         }
     }
 
+    private void dispatchReceivedMessages() {
+        nativeDispatchReceivedMessages(mNativeAppWebMessagePort);
+    }
+
     @Override
     public void postMessage(String message, MessagePort[] sentPorts) throws IllegalStateException {
         if (isClosed() || isTransferred()) {
             throw new IllegalStateException("Port is already closed or transferred");
         }
         AppWebMessagePort[] ports = null;
         if (sentPorts != null) {
             for (MessagePort port : sentPorts) {
                 if (port.equals(this)) {
                     throw new IllegalStateException("Source port cannot be transferred");
                 }
+                if (port.isClosed() || port.isTransferred()) {
+                    throw new IllegalStateException("Port is already closed or transferred");
+                }
+                if (port.isStarted()) {
+                    throw new IllegalStateException("Port is already started");
+                }
             }
             ports = Arrays.copyOf(sentPorts, sentPorts.length, AppWebMessagePort[].class);
         }
         mStarted = true;
-        mPostMessageSender.postMessage(null, message, null, ports);
-    }
-
-    // Implements PostMessageSender.PostMessageSenderDelegate interface method.
-    @Override
-    public boolean isPostMessageSenderReady() {
-        return isReady();
-    }
-
-    // Implements PostMessageSender.PostMessageSenderDelegate interface method.
-    @Override
-    public void onPostMessageQueueEmpty() {
-        if (isClosed()) {
-            cleanup();
-        }
-    }
-
-    // Implements PostMessageSender.PostMessageSenderDelegate interface method.
-    @Override
-    public void postMessageToWeb(
-            String frameName, String message, String targetOrigin, int[] sentPortIds) {
-        mMessagePortService.postMessage(mPortId, message, sentPortIds);
+        nativePostMessage(mNativeAppWebMessagePort, message, ports);

[sgurun-gerrit only, 2017/02/08 21:47:50]

I wonder if these changes create an opportunity for further optimization here
wrt to how we transfer ports. The current logic is:
postMessage -> nativePostMessage -> UnwrapJavaArray { for each port transferred:
Go back to java i.e. releaseNativePortForTransfer: set port as transferred and
uninitialize native ptr. }

Can we do:
postMessage { for each port: mark as transferred/ store native ptr/ reset native
ptr} -> nativePostMessage passing native ptrs. 

But then I guess the question is messageportprovider::postmessagetoframe can
also transfer ports. Himm, ok, nevermind.

[darin (slow to review), 2017/02/09 00:13:17]

Yeah, exactly. I had the same thoughts. I landed on this for the reason you
state. 

     }
 
     private void cleanup() {
-        mMessagePortService.removeObserver(mPostMessageSender);
-        mPostMessageSender = null;
-        mMessagePortService.closePort(mPortId);
+        nativeCloseMessagePort(mNativeAppWebMessagePort);
+        mNativeAppWebMessagePort = UNINITIALIZED_PORT_NATIVE_PTR;
     }
+
+    private static native void nativeInitializeAppWebMessagePortPair(AppWebMessagePort[] ports);
+
+    private native void nativeCloseMessagePort(long nativeAppWebMessagePort);
+    private native void nativePostMessage(long nativeAppWebMessagePort, String message,
+                                          AppWebMessagePort[] ports);
+    private native void nativeDispatchReceivedMessages(long nativeAppWebMessagePort);
+    private native void nativeStartReceivingMessages(long nativeAppWebMessagePort);
 }