[Android] Java Bridge with Gin: implement Java bound object

content/browser/renderer_host/java/gin_java_method_invocation_helper.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 "content/browser/renderer_host/java/gin_java_method_invocation_helper.h"
 
 #include <unistd.h>
 
 #include "base/android/event_log.h"
 #include "base/android/jni_android.h"
@@ skipping 100 matching lines @@
       if (!object_ref.is_empty()) {
         object_refs_.insert(std::make_pair(object_id, object_ref));
       }
     }
   }
   return true;
 }
 
 void GinJavaMethodInvocationHelper::Invoke() {
   JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobject> obj(object_->GetLocalRef(env));
-  if (obj.is_null()) {
-    SetInvocationFailure(kObjectIsGone);
-    return;
-  }
   const JavaMethod* method =
       object_->FindMethod(method_name_, arguments_->GetSize());
   if (!method) {
     SetInvocationFailure(kMethodNotFound);
     return;
   }
 
   if (object_->IsObjectGetClassMethod(method)) {
     base::android::EventLogWriteInt(kObjectGetClassInvocationAttemptLogTag,
                                     getuid());
     SetInvocationFailure(kAccessToObjectGetClassIsBlocked);
     return;
   }
 
+  ScopedJavaLocalRef<jobject> obj;
+  ScopedJavaLocalRef<jclass> cls;
+  if (method->is_static()) {
+    cls = object_->GetLocalClassRef(env);
+  } else {
+    obj = object_->GetLocalRef(env);
+  }
+  if (obj.is_null() && cls.is_null()) {
+    SetInvocationFailure(kObjectIsGone);
+    return;
+  }
+
   std::vector<jvalue> parameters(method->num_parameters());
   for (size_t i = 0; i < method->num_parameters(); ++i) {
     const base::Value* argument;
     arguments_->Get(i, &argument);
     parameters[i] = CoerceJavaScriptValueToJavaValue(
         env, argument, method->parameter_type(i), true, object_refs_);
   }
-  InvokeMethod(obj.obj(), method->return_type(), method->id(), &parameters[0]);
+  if (method->is_static()) {
+    InvokeMethod(
+        NULL, cls.obj(), method->return_type(), method->id(), &parameters[0]);
+  } else {
+    InvokeMethod(
+        obj.obj(), NULL, method->return_type(), method->id(), &parameters[0]);
+  }
 
   // Now that we're done with the jvalue, release any local references created
   // by CoerceJavaScriptValueToJavaValue().
   for (size_t i = 0; i < method->num_parameters(); ++i) {
     ReleaseJavaValueIfRequired(env, &parameters[i], method->parameter_type(i));
   }
 }
 
 void GinJavaMethodInvocationHelper::SetInvocationFailure(
     const char* error_message) {
@@ skipping 32 matching lines @@
 const base::android::JavaRef<jclass>&
 GinJavaMethodInvocationHelper::GetSafeAnnotationClass() {
   return safe_annotation_clazz_;
 }
 
 const std::string& GinJavaMethodInvocationHelper::GetErrorMessage() {
   return error_message_;
 }
 
 void GinJavaMethodInvocationHelper::InvokeMethod(jobject object,
+                                                 jclass clazz,
                                                  const JavaType& return_type,
                                                  jmethodID id,
                                                  jvalue* parameters) {
+  DCHECK(object || clazz);
   JNIEnv* env = AttachCurrentThread();
   base::ListValue result_wrapper;
   switch (return_type.type) {
     case JavaType::TypeBoolean:
       result_wrapper.AppendBoolean(
-          env->CallBooleanMethodA(object, id, parameters));
+          object ? env->CallBooleanMethodA(object, id, parameters)
+                 : env->CallStaticBooleanMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeByte:
       result_wrapper.AppendInteger(
-          env->CallByteMethodA(object, id, parameters));
+          object ? env->CallByteMethodA(object, id, parameters)
+                 : env->CallStaticByteMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeChar:
       result_wrapper.AppendInteger(
-          env->CallCharMethodA(object, id, parameters));
+          object ? env->CallCharMethodA(object, id, parameters)
+                 : env->CallStaticCharMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeShort:
       result_wrapper.AppendInteger(
-          env->CallShortMethodA(object, id, parameters));
+          object ? env->CallShortMethodA(object, id, parameters)
+                 : env->CallStaticShortMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeInt:
       result_wrapper.AppendInteger(
-          env->CallIntMethodA(object, id, parameters));
+          object ? env->CallIntMethodA(object, id, parameters)
+                 : env->CallStaticIntMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeLong:
       result_wrapper.AppendDouble(
-          env->CallLongMethodA(object, id, parameters));
+          object ? env->CallLongMethodA(object, id, parameters)
+                 : env->CallStaticLongMethodA(clazz, id, parameters));
       break;
     case JavaType::TypeFloat: {
-      float result = env->CallFloatMethodA(object, id, parameters);
+      float result = object
+                         ? env->CallFloatMethodA(object, id, parameters)
+                         : env->CallStaticFloatMethodA(clazz, id, parameters);
       if (base::IsFinite(result)) {
         result_wrapper.AppendDouble(result);
       } else {
         result_wrapper.Append(
             GinJavaBridgeValue::CreateNonFiniteValue(result).release());
       }
       break;
     }
     case JavaType::TypeDouble: {
-      double result = env->CallDoubleMethodA(object, id, parameters);
+      double result = object
+                          ? env->CallDoubleMethodA(object, id, parameters)
+                          : env->CallStaticDoubleMethodA(clazz, id, parameters);
       if (base::IsFinite(result)) {
         result_wrapper.AppendDouble(result);
       } else {
         result_wrapper.Append(
             GinJavaBridgeValue::CreateNonFiniteValue(result).release());
       }
       break;
     }
     case JavaType::TypeVoid:
-      env->CallVoidMethodA(object, id, parameters);
+      if (object)
+        env->CallVoidMethodA(object, id, parameters);
+      else
+        env->CallStaticVoidMethodA(clazz, id, parameters);
       result_wrapper.Append(
           GinJavaBridgeValue::CreateUndefinedValue().release());
       break;
     case JavaType::TypeArray:
       // LIVECONNECT_COMPLIANCE: Existing behavior is to not call methods that
       // return arrays. Spec requires calling the method and converting the
       // result to a JavaScript array.
       result_wrapper.Append(
           GinJavaBridgeValue::CreateUndefinedValue().release());
       break;
     case JavaType::TypeString: {
       jstring java_string = static_cast<jstring>(
-          env->CallObjectMethodA(object, id, parameters));
+          object ? env->CallObjectMethodA(object, id, parameters)
+                 : env->CallStaticObjectMethodA(clazz, id, parameters));
       // If an exception was raised, we must clear it before calling most JNI
       // methods. ScopedJavaLocalRef is liable to make such calls, so we test
       // first.
       if (base::android::ClearException(env)) {
         SetInvocationFailure(kJavaExceptionRaised);
         return;
       }
       ScopedJavaLocalRef<jstring> scoped_java_string(env, java_string);
       if (!scoped_java_string.obj()) {
         // LIVECONNECT_COMPLIANCE: Existing behavior is to return undefined.
         // Spec requires returning a null string.
         result_wrapper.Append(
             GinJavaBridgeValue::CreateUndefinedValue().release());
         break;
       }
       result_wrapper.AppendString(
           base::android::ConvertJavaStringToUTF8(scoped_java_string));
       break;
     }
     case JavaType::TypeObject: {
       // If an exception was raised, we must clear it before calling most JNI
       // methods. ScopedJavaLocalRef is liable to make such calls, so we test
       // first.
-      jobject java_object = env->CallObjectMethodA(object, id, parameters);
+      jobject java_object =
+          object ? env->CallObjectMethodA(object, id, parameters)
+                 : env->CallStaticObjectMethodA(clazz, id, parameters);
       if (base::android::ClearException(env)) {
         SetInvocationFailure(kJavaExceptionRaised);
         return;
       }
       ScopedJavaLocalRef<jobject> scoped_java_object(env, java_object);
       if (!scoped_java_object.obj()) {
         result_wrapper.Append(base::Value::CreateNullValue());
         break;
       }
       SetObjectResult(scoped_java_object, object_->GetSafeAnnotationClass());
       return;
     }
   }
   // This is for all cases except JavaType::TypeObject.
   if (!base::android::ClearException(env)) {
     SetPrimitiveResult(result_wrapper);
   } else {
     SetInvocationFailure(kJavaExceptionRaised);
   }
 }
 
 }  // namespace content