[Android] Cache function templates in GinJavaBridgeObject to avoid memory leak

content/renderer/java/gin_java_bridge_object.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/renderer/java/gin_java_bridge_object.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/android/gin_java_bridge_errors.h"
 #include "content/common/android/gin_java_bridge_value.h"
 #include "content/public/child/v8_value_converter.h"
@@ skipping 48 matching lines @@
       blink::mainThreadIsolate(), dispatcher, object_id);
 }
 
 GinJavaBridgeObject::GinJavaBridgeObject(
     v8::Isolate* isolate,
     const base::WeakPtr<GinJavaBridgeDispatcher>& dispatcher,
     GinJavaBridgeDispatcher::ObjectID object_id)
     : gin::NamedPropertyInterceptor(isolate, this),
       dispatcher_(dispatcher),
       object_id_(object_id),
-      converter_(new GinJavaBridgeValueConverter()) {
+      converter_(new GinJavaBridgeValueConverter()),
+      template_cache_(isolate) {
 }
 
 GinJavaBridgeObject::~GinJavaBridgeObject() {
   if (dispatcher_)
     dispatcher_->OnGinJavaBridgeObjectDeleted(object_id_);
 }
 
 gin::ObjectTemplateBuilder GinJavaBridgeObject::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<GinJavaBridgeObject>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
 v8::Local<v8::Value> GinJavaBridgeObject::GetNamedProperty(
     v8::Isolate* isolate,
     const std::string& property) {
   std::map<std::string, bool>::iterator method_pos =
       known_methods_.find(property);
   if (method_pos == known_methods_.end()) {
     if (!dispatcher_) {
       return v8::Local<v8::Value>();
     }
     known_methods_[property] = dispatcher_->HasJavaMethod(object_id_, property);
   }
-  if (known_methods_[property]) {
-    return gin::CreateFunctionTemplate(
-               isolate,
-               base::Bind(&GinJavaBridgeObject::InvokeMethod,
-                          base::Unretained(this),
-                          property))->GetFunction();
-  } else {
+  if (known_methods_[property])
+    return GetFunctionTemplate(isolate, property)->GetFunction();
+  else
     return v8::Local<v8::Value>();
-  }
 }
 
 std::vector<std::string> GinJavaBridgeObject::EnumerateNamedProperties(
     v8::Isolate* isolate) {
   std::set<std::string> method_names;
   if (dispatcher_)
     dispatcher_->GetJavaMethods(object_id_, &method_names);
   return std::vector<std::string> (method_names.begin(), method_names.end());
 }
 
+v8::Local<v8::FunctionTemplate> GinJavaBridgeObject::GetFunctionTemplate(
+    v8::Isolate* isolate,
+    const std::string& name) {
+  v8::Local<v8::FunctionTemplate> function_template = template_cache_.Get(name);
+  if (!function_template.IsEmpty())
+    return function_template;
+  function_template = gin::CreateFunctionTemplate(
+      isolate, base::Bind(&GinJavaBridgeObject::InvokeMethod,
+                          base::Unretained(this), name));
+  template_cache_.Set(name, function_template);
+  return function_template;
+}
+
 v8::Handle<v8::Value> GinJavaBridgeObject::InvokeMethod(
     const std::string& name,
     gin::Arguments* args) {
   if (!dispatcher_) {
     args->isolate()->ThrowException(v8::Exception::Error(gin::StringToV8(
         args->isolate(), kMethodInvocationErrorMessage)));
     return v8::Undefined(args->isolate());
   }
 
   base::ListValue arguments;
@@ skipping 43 matching lines @@
     float float_value;
     gin_value->GetAsNonFinite(&float_value);
     return v8::Number::New(args->isolate(), float_value);
   }
   return v8::Undefined(args->isolate());
 }
 
 gin::WrapperInfo GinJavaBridgeObject::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 }  // namespace content