PPAPI: Make V8VarConverter longer-lived

content/renderer/pepper/resource_converter.cc

 // Copyright 2013 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/resource_converter.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/pepper_file_system_host.h"
@@ skipping 179 matching lines @@
     return true;
   }
 #endif
   return false;
 }
 
 }  // namespace
 
 ResourceConverter::~ResourceConverter() {}
 
-ResourceConverterImpl::ResourceConverterImpl(PP_Instance instance,
-                                             RendererPpapiHost* host)
-    : instance_(instance), host_(host) {}
+ResourceConverterImpl::ResourceConverterImpl(PP_Instance instance)
+    : instance_(instance) {}
 
 ResourceConverterImpl::~ResourceConverterImpl() {
   // Verify Flush() was called.
   DCHECK(browser_host_create_messages_.empty());
   DCHECK(browser_vars_.empty());
 }
 
 bool ResourceConverterImpl::FromV8Value(v8::Handle<v8::Object> val,
                                         v8::Handle<v8::Context> context,
                                         PP_Var* result,
                                         bool* was_resource) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
+  RendererPpapiHost* host = RendererPpapiHost::GetForPPInstance(instance_);
 
   *was_resource = false;
 
   blink::WebDOMFileSystem dom_file_system =
       blink::WebDOMFileSystem::fromV8Value(val);
   if (!dom_file_system.isNull()) {
     int pending_renderer_id;
     scoped_ptr<IPC::Message> create_message;
     scoped_ptr<IPC::Message> browser_host_create_message;
     if (!DOMFileSystemToResource(instance_,
-                                 host_,
+                                 host,
                                  dom_file_system,
                                  &pending_renderer_id,
                                  &create_message,
                                  &browser_host_create_message)) {
       return false;
     }
     DCHECK(create_message);
     DCHECK(browser_host_create_message);
     scoped_refptr<HostResourceVar> result_var =
         CreateResourceVarWithBrowserHost(
             pending_renderer_id, *create_message, *browser_host_create_message);
     *result = result_var->GetPPVar();
     *was_resource = true;
     return true;
   }
 
   blink::WebDOMMediaStreamTrack dom_media_stream_track =
       blink::WebDOMMediaStreamTrack::fromV8Value(val);
   if (!dom_media_stream_track.isNull()) {
     int pending_renderer_id;
     scoped_ptr<IPC::Message> create_message;
     if (!DOMMediaStreamTrackToResource(instance_,
-                                       host_,
+                                       host,
                                        dom_media_stream_track,
                                        &pending_renderer_id,
                                        &create_message)) {
       return false;
     }
     DCHECK(create_message);
     scoped_refptr<HostResourceVar> result_var =
         CreateResourceVar(pending_renderer_id, *create_message);
     *result = result_var->GetPPVar();
     *was_resource = true;
     return true;
   }
 
   // The value was not convertible to a resource. Return true with
   // |was_resource| set to false. As per the interface of FromV8Value, |result|
   // may be left unmodified in this case.
   return true;
 }
 
 void ResourceConverterImpl::Reset() {
   browser_host_create_messages_.clear();
   browser_vars_.clear();
 }
 
 bool ResourceConverterImpl::NeedsFlush() {
   return !browser_host_create_messages_.empty();
 }
 
 void ResourceConverterImpl::Flush(const base::Callback<void(bool)>& callback) {
-  host_->CreateBrowserResourceHosts(
+  RendererPpapiHost::GetForPPInstance(instance_)->CreateBrowserResourceHosts(
       instance_,
       browser_host_create_messages_,
       base::Bind(&FlushComplete, callback, browser_vars_));
   browser_host_create_messages_.clear();
   browser_vars_.clear();
 }
 
 bool ResourceConverterImpl::ToV8Value(const PP_Var& var,
                                       v8::Handle<v8::Context> context,
                                       v8::Handle<v8::Value>* result) {
@@ skipping 54 matching lines @@
     const IPC::Message& create_message,
     const IPC::Message& browser_host_create_message) {
   scoped_refptr<HostResourceVar> result =
       CreateResourceVar(pending_renderer_id, create_message);
   browser_host_create_messages_.push_back(browser_host_create_message);
   browser_vars_.push_back(result);
   return result;
 }
 
 }  // namespace content