[Android] Java Bridge with Gin: implement Java Bridge dispatcher

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"
 #include "base/android/jni_string.h"
 #include "base/float_util.h"
 #include "content/browser/renderer_host/java/gin_java_script_to_java_types_coercion.h"
 #include "content/browser/renderer_host/java/java_method.h"
 #include "content/browser/renderer_host/java/jni_helper.h"
 #include "content/common/android/gin_java_bridge_value.h"
 #include "content/public/browser/browser_thread.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ScopedJavaLocalRef;
 
 namespace content {
 
 namespace {
 
-const char kObjectIsGone[] = "Java object is gone";
-const char kMethodNotFound[] = "Method not found";
-const char kAccessToObjectGetClassIsBlocked[] =
-    "Access to java.lang.Object.getClass is blocked";
-const char kJavaExceptionRaised[] =
-    "Java exception has been raised during method invocation";
-
 // See frameworks/base/core/java/android/webkit/EventLogTags.logtags
 const int kObjectGetClassInvocationAttemptLogTag = 70151;
 
 }  // namespace
 
 GinJavaMethodInvocationHelper::GinJavaMethodInvocationHelper(
     scoped_ptr<ObjectDelegate> object,
     const std::string& method_name,
     const base::ListValue& arguments)
     : object_(object.Pass()),
       method_name_(method_name),
-      arguments_(arguments.DeepCopy()) {
+      arguments_(arguments.DeepCopy()),
+      invocation_error_(kGinJavaBridgeNoError) {
 }
 
 GinJavaMethodInvocationHelper::~GinJavaMethodInvocationHelper() {}
 
 void GinJavaMethodInvocationHelper::Init(DispatcherDelegate* dispatcher) {
   // Build on the UI thread a map of object_id -> WeakRef for Java objects from
   // |arguments_|.  Then we can use this map on the background thread without
   // accessing |dispatcher|.
   BuildObjectRefsFromListValue(dispatcher, arguments_.get());
 }
@@ skipping 59 matching lines @@
     }
   }
   return true;
 }
 
 void GinJavaMethodInvocationHelper::Invoke() {
   JNIEnv* env = AttachCurrentThread();
   const JavaMethod* method =
       object_->FindMethod(method_name_, arguments_->GetSize());
   if (!method) {
-    SetInvocationFailure(kMethodNotFound);
+    SetInvocationError(kGinJavaBridgeMethodNotFound);
     return;
   }
 
   if (object_->IsObjectGetClassMethod(method)) {
     base::android::EventLogWriteInt(kObjectGetClassInvocationAttemptLogTag,
                                     getuid());
-    SetInvocationFailure(kAccessToObjectGetClassIsBlocked);
+    SetInvocationError(kGinJavaBridgeAccessToObjectGetClassIsBlocked);
     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);
+    SetInvocationError(kGinJavaBridgeObjectIsGone);
     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_);
   }
   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) {
+void GinJavaMethodInvocationHelper::SetInvocationError(
+    GinJavaBridgeError error) {
   holds_primitive_result_ = true;
   primitive_result_.reset(new base::ListValue());
-  error_message_ = error_message;
+  invocation_error_ = error;
 }
 
 void GinJavaMethodInvocationHelper::SetPrimitiveResult(
     const base::ListValue& result_wrapper) {
   holds_primitive_result_ = true;
   primitive_result_.reset(result_wrapper.DeepCopy());
 }
 
 void GinJavaMethodInvocationHelper::SetObjectResult(
     const base::android::JavaRef<jobject>& object,
@@ skipping 14 matching lines @@
 const base::android::JavaRef<jobject>&
 GinJavaMethodInvocationHelper::GetObjectResult() {
   return object_result_;
 }
 
 const base::android::JavaRef<jclass>&
 GinJavaMethodInvocationHelper::GetSafeAnnotationClass() {
   return safe_annotation_clazz_;
 }
 
-const std::string& GinJavaMethodInvocationHelper::GetErrorMessage() {
-  return error_message_;
+const GinJavaBridgeError GinJavaMethodInvocationHelper::GetInvocationError() {
+  return invocation_error_;
 }
 
 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;
@@ skipping 68 matching lines @@
           GinJavaBridgeValue::CreateUndefinedValue().release());
       break;
     case JavaType::TypeString: {
       jstring java_string = static_cast<jstring>(
           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);
+        SetInvocationError(kGinJavaBridgeJavaExceptionRaised);
         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 =
           object ? env->CallObjectMethodA(object, id, parameters)
                  : env->CallStaticObjectMethodA(clazz, id, parameters);
       if (base::android::ClearException(env)) {
-        SetInvocationFailure(kJavaExceptionRaised);
+        SetInvocationError(kGinJavaBridgeJavaExceptionRaised);
         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);
+    SetInvocationError(kGinJavaBridgeJavaExceptionRaised);
   }
 }
 
 }  // namespace content