Use the correct v8 context for conversions when calling into the plugin from JS

content/renderer/pepper/pepper_try_catch.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/pepper/pepper_try_catch.h"
 
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "gin/converter.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var_tracker.h"
 
 namespace content {
 
 namespace {
 
 const char kConversionException[] =
     "Error: Failed conversion between PP_Var and V8 value";
 const char kInvalidException[] = "Error: An invalid exception was thrown.";
 
 }  // namespace
 
 PepperTryCatch::PepperTryCatch(PepperPluginInstanceImpl* instance,
                                V8VarConverter::AllowObjectVars convert_objects)
     : instance_(instance),
       convert_objects_(convert_objects) {}
 
 PepperTryCatch::~PepperTryCatch() {}
 
-v8::Handle<v8::Context> PepperTryCatch::GetContext() {
-  return instance_->GetContext();
-}
-
 v8::Handle<v8::Value> PepperTryCatch::ToV8(PP_Var var) {
   if (HasException()) {
     SetException(kConversionException);
     return v8::Handle<v8::Value>();
   }
 
   V8VarConverter converter(instance_->pp_instance(), convert_objects_);
   v8::Handle<v8::Value> result;
   bool success = converter.ToV8Value(var, GetContext(), &result);
   if (!success) {
@@ skipping 35 matching lines @@
 }
 
 PepperTryCatchV8::~PepperTryCatchV8() {
   ppapi::PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(exception_);
 }
 
 bool PepperTryCatchV8::HasException() {
   return GetContext().IsEmpty() || exception_.type != PP_VARTYPE_UNDEFINED;
 }
 
+v8::Handle<v8::Context> PepperTryCatchV8::GetContext() {
+  // When calling from JS into the plugin always use the current context.
+  return instance_->GetIsolate()->GetCurrentContext();
+}
+
 bool PepperTryCatchV8::ThrowException() {
   if (!HasException())
     return false;
 
-  // If the plugin context is gone, then we have an exception but we don't try
-  // to throw it into v8.
+  // If there is no context then we have an exception but we don't try to throw
+  // it into v8.
   if (GetContext().IsEmpty())
     return true;
 
   std::string message(kInvalidException);
   ppapi::StringVar* message_var = ppapi::StringVar::FromPPVar(exception_);
   if (message_var)
     message = message_var->value();
   instance_->GetIsolate()->ThrowException(v8::Exception::Error(
       gin::StringToV8(instance_->GetIsolate(), message)));
 
@@ skipping 45 matching lines @@
 
   if (!exception_message.empty()) {
     exception_is_set_ = true;
     if (exception_)
       *exception_ = ppapi::StringVar::StringToPPVar(exception_message);
   }
 
   return exception_is_set_;
 }
 
+v8::Handle<v8::Context> PepperTryCatchVar::GetContext() {
+  // When calling into JS from the plugin, always use the plugin context.
+  return instance_->GetMainWorldContext();
+}
+
 void PepperTryCatchVar::SetException(const char* message) {
   if (exception_is_set_)
     return;
 
   if (exception_)
     *exception_ = ppapi::StringVar::StringToPPVar(message, strlen(message));
   exception_is_set_ = true;
 }
 
 }  // namespace content