PPAPI: Make V8VarConverter longer-lived

content/renderer/pepper/message_channel.cc

 // Copyright (c) 2012 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/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/pepper_try_catch.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/plugin_object.h"
 #include "content/renderer/pepper/v8_var_converter.h"

[raymes, 2014/10/09 22:04:42]

nit: I guess we can remove this.

[dmichael (off chromium), 2014/10/09 22:45:37]

Done.

 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/function_template.h"
 #include "gin/object_template_builder.h"
 #include "gin/public/gin_embedders.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
@@ skipping 86 matching lines @@
 
   // Because V8 is probably not on the stack for Native->JS calls, we need to
   // enter the appropriate context for the plugin.
   v8::Local<v8::Context> context = instance_->GetMainWorldContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   v8::Handle<v8::Value> v8_val;
-  if (!V8VarConverter(instance_->pp_instance())
-           .ToV8Value(message_data, context, &v8_val)) {
+  if (!var_converter_.ToV8Value(message_data, context, &v8_val)) {
     PpapiGlobals::Get()->LogWithSource(instance_->pp_instance(),
                                        PP_LOGLEVEL_ERROR,
                                        std::string(),
                                        kVarToV8ConversionError);
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
 
@@ skipping 43 matching lines @@
     NOTREACHED();
   }
 }
 
 MessageChannel::MessageChannel(PepperPluginInstanceImpl* instance)
     : gin::NamedPropertyInterceptor(instance->GetIsolate(), this),
       instance_(instance),
       js_message_queue_state_(WAITING_TO_START),
       blocking_message_depth_(0),
       plugin_message_queue_state_(WAITING_TO_START),
+      var_converter_(instance->pp_instance(),
+                     V8VarConverter::kDisallowObjectVars),
       weak_ptr_factory_(this) {
 }
 
 gin::ObjectTemplateBuilder MessageChannel::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<MessageChannel>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
 void MessageChannel::BeginBlockOnSyncMessage() {
   js_message_queue_state_ = QUEUE_MESSAGES;
   ++blocking_message_depth_;
 }
 
 void MessageChannel::EndBlockOnSyncMessage() {
   DCHECK_GT(blocking_message_depth_, 0);
   --blocking_message_depth_;
   if (!blocking_message_depth_)
     DrainJSMessageQueueSoon();
 }
 
 v8::Local<v8::Value> MessageChannel::GetNamedProperty(
     v8::Isolate* isolate,
     const std::string& identifier) {
   if (!instance_)
     return v8::Local<v8::Value>();
 
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kDisallowObjectVars,
-                             isolate);
+  PepperTryCatchV8 try_catch(instance_, &var_converter_, isolate);
   if (identifier == kPostMessage) {
     return gin::CreateFunctionTemplate(isolate,
         base::Bind(&MessageChannel::PostMessageToNative,
                    weak_ptr_factory_.GetWeakPtr()))->GetFunction();
   } else if (identifier == kPostMessageAndAwaitResponse) {
     return gin::CreateFunctionTemplate(isolate,
         base::Bind(&MessageChannel::PostBlockingMessageToNative,
                    weak_ptr_factory_.GetWeakPtr()))->GetFunction();
   }
 
@@ skipping 10 matching lines @@
   if (plugin_object)
     return plugin_object->GetNamedProperty(isolate, identifier);
   return v8::Local<v8::Value>();
 }
 
 bool MessageChannel::SetNamedProperty(v8::Isolate* isolate,
                                       const std::string& identifier,
                                       v8::Local<v8::Value> value) {
   if (!instance_)
     return false;
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kDisallowObjectVars,
-                             isolate);
+  PepperTryCatchV8 try_catch(instance_, &var_converter_, isolate);
   if (identifier == kPostMessage ||
       (identifier == kPostMessageAndAwaitResponse)) {
     try_catch.ThrowException("Cannot set properties with the name postMessage"
                              "or postMessageAndAwaitResponse");
     return true;
   }
 
   // We don't forward this to the passthrough object; no plugins use that
   // feature.
   // TODO(raymes): Remove SetProperty support from PPP_Class.
@@ skipping 26 matching lines @@
     NOTREACHED();
   }
 
   EnqueuePluginMessage(message_data);
   DrainCompletedPluginMessages();
 }
 
 void MessageChannel::PostBlockingMessageToNative(gin::Arguments* args) {
   if (!instance_)
     return;
-  PepperTryCatchV8 try_catch(instance_, V8VarConverter::kDisallowObjectVars,
-                             args->isolate());
+  PepperTryCatchV8 try_catch(instance_, &var_converter_, args->isolate());
   if (args->Length() != 1) {
     try_catch.ThrowException(
         "postMessageAndAwaitResponse requires one argument");
     return;
   }
 
   v8::Handle<v8::Value> message_data;
   if (!args->GetNext(&message_data)) {
     NOTREACHED();
   }
@@ skipping 73 matching lines @@
   container->element().dispatchEvent(msg_event);
 }
 
 PluginObject* MessageChannel::GetPluginObject(v8::Isolate* isolate) {
   return PluginObject::FromV8Object(isolate,
       v8::Local<v8::Object>::New(isolate, passthrough_object_));
 }
 
 void MessageChannel::EnqueuePluginMessage(v8::Handle<v8::Value> v8_value) {
   plugin_message_queue_.push_back(VarConversionResult());
-  // Convert NPVariantType_Object in to an appropriate PP_Var like Dictionary,
-  // Array, etc. Note NPVariantToVar would convert to an "Object" PP_Var,
-  // which we don't support for Messaging.
+  // Convert the v8 value in to an appropriate PP_Var like Dictionary,
+  // Array, etc. (We explicitly don't want an "Object" PP_Var, which we don't
+  // support for Messaging.)
   // TODO(raymes): Possibly change this to use TryCatch to do the conversion and
   // throw an exception if necessary.
-  V8VarConverter v8_var_converter(instance_->pp_instance());
   V8VarConverter::VarResult conversion_result =
-      v8_var_converter.FromV8Value(
+      var_converter_.FromV8Value(
           v8_value,
           v8::Isolate::GetCurrent()->GetCurrentContext(),
           base::Bind(&MessageChannel::FromV8ValueComplete,
                      weak_ptr_factory_.GetWeakPtr(),
                      &plugin_message_queue_.back()));
   if (conversion_result.completed_synchronously) {
     plugin_message_queue_.back().ConversionCompleted(
         conversion_result.var,
         conversion_result.success);
   }
@@ skipping 53 matching lines @@
 }
 
 void MessageChannel::UnregisterSyncMessageStatusObserver() {
   if (!unregister_observer_callback_.is_null()) {
     unregister_observer_callback_.Run();
     unregister_observer_callback_.Reset();
   }
 }
 
 }  // namespace content