Cache function templates in PluginObject to avoid memory leak.

content/renderer/pepper/plugin_object.cc

 // Copyright (c) 2011 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/pepper/plugin_object.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 151 matching lines @@
   instance_ = NULL;
 }
 
 PluginObject::PluginObject(PepperPluginInstanceImpl* instance,
                            const PPP_Class_Deprecated* ppp_class,
                            void* ppp_class_data)
     : gin::NamedPropertyInterceptor(instance->GetIsolate(), this),
       instance_(instance),
       ppp_class_(ppp_class),
       ppp_class_data_(ppp_class_data),
-      weak_factory_(this) {
+      weak_factory_(this),
+      template_cache_(instance->GetIsolate()) {
   instance_->AddPluginObject(this);
 }
 
 gin::ObjectTemplateBuilder PluginObject::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<PluginObject>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
 v8::Local<v8::Value> PluginObject::GetPropertyOrMethod(v8::Isolate* isolate,
@@ skipping 26 matching lines @@
 
   bool has_method = identifier_var.type == PP_VARTYPE_STRING &&
                     ppp_class_->HasMethod(ppp_class_data_, identifier_var,
                                           try_catch.exception());
   if (try_catch.ThrowException())
     return v8::Local<v8::Value>();
 
   if (has_method) {
     const std::string& identifier =
         StringVar::FromPPVar(identifier_var)->value();
-    return gin::CreateFunctionTemplate(isolate,
-                                       base::Bind(&PluginObject::Call,
-                                                  weak_factory_.GetWeakPtr(),
-                                                  identifier))->GetFunction();
+    return GetFunctionTemplate(isolate, identifier)->GetFunction();
   }
 
   return v8::Local<v8::Value>();
 }
 
 void PluginObject::Call(const std::string& identifier,
                         gin::Arguments* args) {
   if (!instance_)
     return;
 
@@ skipping 28 matching lines @@
   if (try_catch.ThrowException())
     return;
 
   v8::Handle<v8::Value> result = try_catch.ToV8(result_var.get());
   if (try_catch.ThrowException())
     return;
 
   args->Return(result);
 }
 
+v8::Local<v8::FunctionTemplate> PluginObject::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(&PluginObject::Call, weak_factory_.GetWeakPtr(),
+                              name));
+  template_cache_.Set(name, function_template);
+  return function_template;
+}
+
 }  // namespace content