Data channel implementation for SessionDependencyFactory.

components/devtools_bridge/android/session_dependency_factory_android.cc

 // 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.
 
 #include "components/devtools_bridge/android/session_dependency_factory_android.h"
 
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "components/devtools_bridge/abstract_data_channel.h"
@@ skipping 23 matching lines @@
     Java_SessionDependencyFactoryNative_notifyIceConnectionChange(
         env, java_object_.obj(), connected);
   }
 
   virtual void OnIceCandidate(
       const std::string& sdp_mid, int sdp_mline_index, const std::string& sdp)
       override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyIceCandidate(
         env, java_object_.obj(),
-        ConvertUTF8ToJavaString(env, sdp_mid).Release(),
-        sdp_mline_index, ConvertUTF8ToJavaString(env, sdp).Release());
+        ConvertUTF8ToJavaString(env, sdp_mid).obj(),

[mnaganov (inactive), 2014/11/18 03:38:59]

Yeah, this looks unusual compared to the rest of the Chromium code, but I think,
I'm understanding the reason -- as you are doing calls into Java initiated from
the native side, JVM will not be clearing local references automatically, as it
does in the case of a Java -> native call. Thus, not releasing the string
reference and relying on ~ScopedJavaLocalRef to perform local reference cleanup
looks like the right thing to do.

But, I'm concerned that when adding another function, it will be easy to forget
about this. As I don't see a solution that could be enforced on the language
level, maybe at least add a comment on the top of the class which would warn
about the need to delete local references in the callbacks?

[SeRya, 2014/11/18 06:57:26]

Done.

+        sdp_mline_index, ConvertUTF8ToJavaString(env, sdp).obj());
   }
 
   void NotifyLocalOfferCreatedAndSetSet(const std::string& description) {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyLocalOfferCreatedAndSetSet(
         env, java_object_.obj(),
-        ConvertUTF8ToJavaString(env, description).Release());
+        ConvertUTF8ToJavaString(env, description).obj());
   }
 
   virtual void OnLocalOfferCreatedAndSetSet(const std::string& description)
       override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyLocalOfferCreatedAndSetSet(
         env, java_object_.obj(),
-        ConvertUTF8ToJavaString(env, description).Release());
+        ConvertUTF8ToJavaString(env, description).obj());
   }
 
   virtual void OnLocalAnswerCreatedAndSetSet(const std::string& description)
       override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyLocalAnswerCreatedAndSetSet(
         env, java_object_.obj(),
-        ConvertUTF8ToJavaString(env, description).Release());
+        ConvertUTF8ToJavaString(env, description).obj());
   }
 
   virtual void OnRemoteDescriptionSet() override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyRemoteDescriptionSet(
         env, java_object_.obj());
   }
 
   virtual void OnFailure(const std::string& description) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyConnectionFailure(
         env, java_object_.obj(),
-        ConvertUTF8ToJavaString(env, description).Release());
+        ConvertUTF8ToJavaString(env, description).obj());
   }
 
  private:
   base::android::ScopedJavaGlobalRef<jobject> java_object_;
   bool connected_;
 };
 
+class DataChannelObserverImpl : public AbstractDataChannel::Observer {
+ public:
+  DataChannelObserverImpl(JNIEnv* env, jobject java_object) {
+    java_object_.Reset(env, java_object);
+  }
+
+  virtual void OnOpen() override {
+    JNIEnv* env = AttachCurrentThread();
+    Java_SessionDependencyFactoryNative_notifyChannelOpen(
+        env, java_object_.obj());
+  }
+
+  virtual void OnClose() override {
+    JNIEnv* env = AttachCurrentThread();
+    Java_SessionDependencyFactoryNative_notifyChannelClose(
+        env, java_object_.obj());
+  }
+
+  virtual void OnMessage(const void* data, size_t length) override {
+    JNIEnv* env = AttachCurrentThread();
+
+    ScopedJavaLocalRef<jobject> byte_buffer(
+        env, env->NewDirectByteBuffer(const_cast<void*>(data), length));
+
+    Java_SessionDependencyFactoryNative_notifyMessage(
+        env, java_object_.obj(), byte_buffer.obj());
+  }
+
+ private:
+  base::android::ScopedJavaGlobalRef<jobject> java_object_;
+};
+
 static void CleanupOnSignalingThread() {
   // Called on signaling thread when SessionDependencyFactory is destroying.
   base::android::DetachFromVM();
 }
 
 }  // namespace
 
 // SessionDependencyFactoryNative
 
 SessionDependencyFactoryAndroid::SessionDependencyFactoryAndroid()
@@ skipping 15 matching lines @@
     scoped_ptr<AbstractPeerConnection::Delegate> delegate) {
   return impl_->CreatePeerConnection(config.Pass(), delegate.Pass());
 }
 
 // JNI generated methods
 
 static jlong CreateFactory(JNIEnv* env, jclass jcaller) {
   return reinterpret_cast<jlong>(new SessionDependencyFactoryAndroid());
 }
 
-static void DestroyFactory(JNIEnv* env, jclass jcaller, jlong factoryPtr) {
-  delete reinterpret_cast<SessionDependencyFactoryAndroid*>(factoryPtr);
+static void DestroyFactory(JNIEnv* env, jclass jcaller, jlong factory_ptr) {
+  delete reinterpret_cast<SessionDependencyFactoryAndroid*>(factory_ptr);
 }
 
 static jlong CreateConfig(JNIEnv* env, jclass jcaller) {
   return reinterpret_cast<jlong>(
       RTCConfiguration::CreateInstance().release());
 }
 
 static void AddIceServer(
-    JNIEnv* env, jclass jcaller, jlong configPtr,
+    JNIEnv* env, jclass jcaller, jlong config_ptr,
     jstring uri, jstring username, jstring credential) {
-  reinterpret_cast<RTCConfiguration*>(configPtr)->AddIceServer(
+  reinterpret_cast<RTCConfiguration*>(config_ptr)->AddIceServer(
       ConvertJavaStringToUTF8(env, uri),
       ConvertJavaStringToUTF8(env, username),
       ConvertJavaStringToUTF8(env, credential));
 }
 
 static jlong CreatePeerConnection(
     JNIEnv* env, jclass jcaller,
-    jlong factoryPtr, jlong configPtr, jobject observer) {
+    jlong factory_ptr, jlong config_ptr, jobject observer) {
   auto factory =
-      reinterpret_cast<SessionDependencyFactoryAndroid*>(factoryPtr);
-  auto config = reinterpret_cast<RTCConfiguration*>(configPtr);
+      reinterpret_cast<SessionDependencyFactoryAndroid*>(factory_ptr);
+  auto config = reinterpret_cast<RTCConfiguration*>(config_ptr);
 
   auto delegate = new PeerConnectionDelegateImpl(env, observer);
 
   return reinterpret_cast<jlong>(factory->CreatePeerConnection(
          make_scoped_ptr(config), make_scoped_ptr(delegate)).release());
 }
 
 static void DestroyPeerConnection(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr) {
-  delete reinterpret_cast<AbstractPeerConnection*>(connectionPtr);
+    JNIEnv* env, jclass jcaller, jlong connection_ptr) {
+  delete reinterpret_cast<AbstractPeerConnection*>(connection_ptr);
 }
 
 static void CreateAndSetLocalOffer(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr) {
+    JNIEnv* env, jclass jcaller, jlong connection_ptr) {
   reinterpret_cast<AbstractPeerConnection*>(
-      connectionPtr)->CreateAndSetLocalOffer();
+      connection_ptr)->CreateAndSetLocalOffer();
 }
 
 static void CreateAndSetLocalAnswer(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr) {
+    JNIEnv* env, jclass jcaller, jlong connection_ptr) {
   reinterpret_cast<AbstractPeerConnection*>(
-      connectionPtr)->CreateAndSetLocalAnswer();
+      connection_ptr)->CreateAndSetLocalAnswer();
 }
 
 static void SetRemoteOffer(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr, jstring description) {
-  reinterpret_cast<AbstractPeerConnection*>(connectionPtr)->SetRemoteOffer(
+    JNIEnv* env, jclass jcaller, jlong connection_ptr, jstring description) {
+  reinterpret_cast<AbstractPeerConnection*>(connection_ptr)->SetRemoteOffer(
       ConvertJavaStringToUTF8(env, description));
 }
 
 static void SetRemoteAnswer(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr, jstring description) {
-  reinterpret_cast<AbstractPeerConnection*>(connectionPtr)->SetRemoteAnswer(
+    JNIEnv* env, jclass jcaller, jlong connection_ptr, jstring description) {
+  reinterpret_cast<AbstractPeerConnection*>(connection_ptr)->SetRemoteAnswer(
       ConvertJavaStringToUTF8(env, description));
 }
 
 static void AddIceCandidate(
     JNIEnv* env, jclass jcaller,
-    jlong connectionPtr, jstring sdpMid, jint sdpMLineIndex, jstring sdp) {
-  reinterpret_cast<AbstractPeerConnection*>(connectionPtr)->AddIceCandidate(
-      ConvertJavaStringToUTF8(env, sdpMid),
-      sdpMLineIndex,
+    jlong connection_ptr, jstring sdp_mid, jint sdp_mline_index, jstring sdp) {
+  reinterpret_cast<AbstractPeerConnection*>(connection_ptr)->AddIceCandidate(
+      ConvertJavaStringToUTF8(env, sdp_mid),
+      sdp_mline_index,
       ConvertJavaStringToUTF8(env, sdp));
 }
 
 static jlong CreateDataChannel(
-    JNIEnv* env, jclass jcaller, jlong connectionPtr, jint channelId) {
+    JNIEnv* env, jclass jcaller, jlong connection_ptr, jint channel_id) {
   return reinterpret_cast<jlong>(
       reinterpret_cast<AbstractPeerConnection*>(
-          connectionPtr)->CreateDataChannel(channelId).release());
+          connection_ptr)->CreateDataChannel(channel_id).release());
 }
 
 static void DestroyDataChannel(
-    JNIEnv* env, jclass jcaller, jlong channelPtr) {
-  delete reinterpret_cast<AbstractDataChannel*>(channelPtr);
+    JNIEnv* env, jclass jcaller, jlong channel_ptr) {
+  delete reinterpret_cast<AbstractDataChannel*>(channel_ptr);
+}
+
+static void RegisterDataChannelObserver(
+    JNIEnv* env, jclass jcaller, jlong channel_ptr, jobject observer) {
+  reinterpret_cast<AbstractDataChannel*>(channel_ptr)->RegisterObserver(
+      make_scoped_ptr(new DataChannelObserverImpl(env, observer)));
+}
+
+static void UnregisterDataChannelObserver(
+    JNIEnv* env, jclass jcaller, jlong channel_ptr) {
+  reinterpret_cast<AbstractDataChannel*>(channel_ptr)->UnregisterObserver();
+}
+
+static void SendBinaryMessage(
+    JNIEnv* env, jclass jcaller, jlong channel_ptr, jobject message,
+    jint size) {
+  DCHECK(size > 0);
+  reinterpret_cast<AbstractDataChannel*>(channel_ptr)->SendBinaryMessage(
+      env->GetDirectBufferAddress(message), size);
+}
+
+static void SendTextMessage(
+    JNIEnv* env, jclass jcaller, jlong channel_ptr, jobject message,
+    jint size) {
+  DCHECK(size > 0);
+  reinterpret_cast<AbstractDataChannel*>(channel_ptr)->SendTextMessage(
+      env->GetDirectBufferAddress(message), size);
+}
+
+static void CloseDataChannel(JNIEnv* env, jclass jcaller, jlong channel_ptr) {
+  reinterpret_cast<AbstractDataChannel*>(channel_ptr)->Close();
 }
 
 }  // namespace android
 }  // namespace devtools_bridge