PPAPI: Make V8VarConverter longer-lived

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 53 matching lines @@
       gin::ConvertFromV8(isolate, v8_object, &plugin_object)) {
     return plugin_object;
   }
   return NULL;
 }
 
 // static
 PP_Var PluginObject::Create(PepperPluginInstanceImpl* instance,
                             const PPP_Class_Deprecated* ppp_class,
                             void* ppp_class_data) {
-  PepperTryCatchVar try_catch(instance, NULL);
+  V8VarConverter var_converter(instance->pp_instance(),
+                               V8VarConverter::kAllowObjectVars);
+  PepperTryCatchVar try_catch(instance, &var_converter, NULL);
   gin::Handle<PluginObject> object =
       gin::CreateHandle(instance->GetIsolate(),
                         new PluginObject(instance, ppp_class, ppp_class_data));
   ScopedPPVar result = try_catch.FromV8(object.ToV8());
   DCHECK(!try_catch.HasException());
   return result.Release();
 }
 
 v8::Local<v8::Value> PluginObject::GetNamedProperty(
     v8::Isolate* isolate,
     const std::string& identifier) {
   ScopedPPVar identifier_var(ScopedPPVar::PassRef(),
                              StringVar::StringToPPVar(identifier));
   return GetPropertyOrMethod(instance_->GetIsolate(), identifier_var.get());
 }
 
 bool PluginObject::SetNamedProperty(v8::Isolate* isolate,
                                     const std::string& identifier,
                                     v8::Local<v8::Value> value) {
   if (!instance_)
     return false;
   ScopedPPVar identifier_var(ScopedPPVar::PassRef(),
                              StringVar::StringToPPVar(identifier));
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kAllowObjectVars,
-                             isolate);
+  V8VarConverter var_converter(instance_->pp_instance(),
+                               V8VarConverter::kAllowObjectVars);
+  PepperTryCatchV8 try_catch(instance_, &var_converter, isolate);
 
   bool has_property =
       ppp_class_->HasProperty(ppp_class_data_, identifier_var.get(),
                               try_catch.exception());
   if (try_catch.ThrowException())
     return false;
 
   if (!has_property)
     return false;
 
@@ skipping 10 matching lines @@
   try_catch.ThrowException();
   return true;
 }
 
 std::vector<std::string> PluginObject::EnumerateNamedProperties(
     v8::Isolate* isolate) {
   std::vector<std::string> result;
   if (!instance_)
     return result;
 
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kAllowObjectVars,
-                             isolate);
+  V8VarConverter var_converter(instance_->pp_instance(),
+                               V8VarConverter::kAllowObjectVars);
+  PepperTryCatchV8 try_catch(instance_, &var_converter, isolate);
 
   PP_Var* name_vars;
   uint32_t count = 0;
   ppp_class_->GetAllPropertyNames(ppp_class_data_, &count, &name_vars,
                                   try_catch.exception());
   ScopedPPVarArray scoped_name_vars(
       ScopedPPVarArray::PassPPBMemoryAllocatedArray(), name_vars, count);
 
   if (try_catch.ThrowException())
     return result;
@@ skipping 31 matching lines @@
     v8::Isolate* isolate) {
   return Wrappable<PluginObject>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
 v8::Local<v8::Value> PluginObject::GetPropertyOrMethod(v8::Isolate* isolate,
                                                        PP_Var identifier_var) {
   if (!instance_)
     return v8::Local<v8::Value>();
 
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kAllowObjectVars,
-                             isolate);
+  V8VarConverter var_converter(instance_->pp_instance(),
+                               V8VarConverter::kAllowObjectVars);
+  PepperTryCatchV8 try_catch(instance_, &var_converter, isolate);
   bool has_property =
       ppp_class_->HasProperty(ppp_class_data_, identifier_var,
                               try_catch.exception());
   if (try_catch.ThrowException())
     return v8::Local<v8::Value>();
 
   if (has_property) {
     ScopedPPVar result_var(ScopedPPVar::PassRef(),
         ppp_class_->GetProperty(ppp_class_data_, identifier_var,
                                 try_catch.exception()));
@@ skipping 23 matching lines @@
   }
 
   return v8::Local<v8::Value>();
 }
 
 void PluginObject::Call(const std::string& identifier,
                         gin::Arguments* args) {
   if (!instance_)
     return;
 
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kAllowObjectVars,
-                             args->isolate());
+  V8VarConverter var_converter(instance_->pp_instance(),
+                               V8VarConverter::kAllowObjectVars);
+  PepperTryCatchV8 try_catch(instance_, &var_converter, args->isolate());
   ScopedPPVar identifier_var(ScopedPPVar::PassRef(),
                              StringVar::StringToPPVar(identifier));
   ScopedPPVarArray argument_vars(args->Length());
 
   for (uint32_t i = 0; i < argument_vars.size(); ++i) {
     v8::Handle<v8::Value> arg;
     if (!args->GetNext(&arg)) {
       NOTREACHED();
     }
 
@@ skipping 16 matching lines @@
     return;
 
   v8::Handle<v8::Value> result = try_catch.ToV8(result_var.get());
   if (try_catch.ThrowException())
     return;
 
   args->Return(result);
 }
 
 }  // namespace content