Add a function template cache to the interceptor unittest

gin/interceptor_unittest.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 "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/interceptor.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/test/v8_test.h"
 #include "gin/try_catch.h"
 #include "gin/wrappable.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "v8/include/v8-util.h"
 
 namespace gin {
 
 class MyInterceptor : public Wrappable<MyInterceptor>,
                       public NamedPropertyInterceptor,
                       public IndexedPropertyInterceptor {
  public:
   static WrapperInfo kWrapperInfo;
 
   static gin::Handle<MyInterceptor> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyInterceptor(isolate));
   }
 
   int value() const { return value_; }
   void set_value(int value) { value_ = value; }
 
   // gin::NamedPropertyInterceptor
   virtual v8::Local<v8::Value> GetNamedProperty(v8::Isolate* isolate,
                                                 const std::string& property)
       OVERRIDE {
     if (property == "value") {
       return ConvertToV8(isolate, value_);
     } else if (property == "func") {
-      return CreateFunctionTemplate(isolate,
-                                    base::Bind(&MyInterceptor::Call),
-                                    HolderIsFirstArgument)->GetFunction();
+      return GetFunctionTemplate(isolate, "func")->GetFunction();
     } else {
       return v8::Local<v8::Value>();
     }
   }
   virtual void SetNamedProperty(v8::Isolate* isolate,
                                 const std::string& property,
                                 v8::Local<v8::Value> value) OVERRIDE {
     if (property != "value")
       return;
     ConvertFromV8(isolate, value, &value_);
@@ skipping 24 matching lines @@
       OVERRIDE {
     std::vector<uint32_t> result;
     result.push_back(0);
     return result;
   }
 
  private:
   explicit MyInterceptor(v8::Isolate* isolate)
       : NamedPropertyInterceptor(isolate, this),
         IndexedPropertyInterceptor(isolate, this),
-        value_(0) {}
+        value_(0),
+        template_cache_(isolate) {}
   virtual ~MyInterceptor() {}
 
   // gin::Wrappable
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate)
       OVERRIDE {
     return Wrappable<MyInterceptor>::GetObjectTemplateBuilder(isolate)
         .AddNamedPropertyInterceptor()
         .AddIndexedPropertyInterceptor();
   }
 
   int Call(int value) {
     int tmp = value_;
     value_ = value;
     return tmp;
   }
 
+  v8::Local<v8::FunctionTemplate> 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 = CreateFunctionTemplate(
+        isolate, base::Bind(&MyInterceptor::Call), HolderIsFirstArgument);
+    template_cache_.Set(name, function_template);
+    return function_template;
+  }
+
   int value_;
+
+  v8::StdPersistentValueMap<std::string, v8::FunctionTemplate> template_cache_;
+
+  DISALLOW_COPY_AND_ASSIGN(MyInterceptor);
 };
 
 WrapperInfo MyInterceptor::kWrapperInfo = {kEmbedderNativeGin};
 
 class InterceptorTest : public V8Test {
  public:
   void RunInterceptorTest(const std::string& script_source) {
     v8::Isolate* isolate = instance_->isolate();
     v8::HandleScope handle_scope(isolate);
 
@@ skipping 36 matching lines @@
 }
 
 TEST_F(InterceptorTest, IndexedInterceptor) {
   RunInterceptorTest(
       "(function (obj) {"
       "   if (obj[0] !== 42) throw 'FAIL';"
       "   else obj[0] = 191; })");
 }
 
 }  // namespace gin