Add a unified resource tracker shared between the proxy and the impl.

webkit/plugins/ppapi/resource_creation_impl.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 "webkit/plugins/ppapi/resource_creation_impl.h"
 
 #include "ppapi/c/pp_size.h"
 #include "ppapi/shared_impl/input_event_impl.h"
 #include "ppapi/shared_impl/var.h"
 #include "webkit/plugins/ppapi/common.h"
@@ skipping 21 matching lines @@
 #include "webkit/plugins/ppapi/ppb_video_capture_impl.h"
 #include "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 #include "webkit/plugins/ppapi/ppb_video_layer_impl.h"
 
 using ppapi::InputEventData;
 using ppapi::StringVar;
 
 namespace webkit {
 namespace ppapi {
 
-namespace {
-
-// We use two methods for creating resources. When the resource initialization
-// is simple and can't fail, just do
-//   return ReturnResource(new PPB_Foo_Impl(instance_, ...));
-// This will set up everything necessary.
-//
-// If the resource is more complex, generally the best thing is to write a
-// static "Create" function on the resource class that returns a PP_Resource
-// or 0 on failure. That helps keep the resource-specific stuff localized and
-// this class very simple.
-PP_Resource ReturnResource(Resource* resource) {
-  // We actually have to keep a ref here since the argument will not be ref'ed
-  // at all if it was just passed in with new (the expected usage). The
-  // returned PP_Resource created by GetReference will hold onto a ref on
-  // behalf of the plugin which will outlive this function. So the end result
-  // will be a Resource with one ref.
-  scoped_refptr<Resource> ref(resource);
-  return resource->GetReference();
-}
-
-}  // namespace
-
-
 ResourceCreationImpl::ResourceCreationImpl(PluginInstance* instance)
     : instance_(instance) {
 }
 
 ResourceCreationImpl::~ResourceCreationImpl() {
 }
 
 ::ppapi::thunk::ResourceCreationAPI*
 ResourceCreationImpl::AsResourceCreationAPI() {
   return this;
@@ skipping 11 matching lines @@
 PP_Resource ResourceCreationImpl::CreateAudioConfig(
     PP_Instance instance_id,
     PP_AudioSampleRate sample_rate,
     uint32_t sample_frame_count) {
   return PPB_AudioConfig_Impl::Create(instance_, sample_rate,
                                        sample_frame_count);
 }
 
 PP_Resource ResourceCreationImpl::CreateAudioTrusted(
     PP_Instance instance_id) {
-  return ReturnResource(new PPB_Audio_Impl(instance_));
+  return (new PPB_Audio_Impl(instance_))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateBroker(PP_Instance instance) {
-  return ReturnResource(new PPB_Broker_Impl(instance_));
+  return (new PPB_Broker_Impl(instance_))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateBuffer(PP_Instance instance,
                                                uint32_t size) {
   return PPB_Buffer_Impl::Create(instance_, size);
 }
 
 PP_Resource ResourceCreationImpl::CreateContext3D(
     PP_Instance instance,
     PP_Config3D_Dev config,
@@ skipping 17 matching lines @@
   return PPB_DirectoryReader_Impl::Create(directory_ref);
 }
 
 PP_Resource ResourceCreationImpl::CreateFileChooser(
     PP_Instance instance,
     const PP_FileChooserOptions_Dev* options) {
   return PPB_FileChooser_Impl::Create(instance_, options);
 }
 
 PP_Resource ResourceCreationImpl::CreateFileIO(PP_Instance instance) {
-  return ReturnResource(new PPB_FileIO_Impl(instance_));
+  return (new PPB_FileIO_Impl(instance_))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateFileRef(PP_Resource file_system,
                                                 const char* path) {
   return PPB_FileRef_Impl::Create(file_system, path);
 }
 
 PP_Resource ResourceCreationImpl::CreateFileSystem(
     PP_Instance instance,
     PP_FileSystemType type) {
   return PPB_FileSystem_Impl::Create(instance_, type);
 }
 
 PP_Resource ResourceCreationImpl::CreateFlashMenu(
     PP_Instance instance,
     const PP_Flash_Menu* menu_data) {
   return PPB_Flash_Menu_Impl::Create(instance_, menu_data);
 }
 
 PP_Resource ResourceCreationImpl::CreateFlashNetConnector(
     PP_Instance instance) {
-  return ReturnResource(new PPB_Flash_NetConnector_Impl(instance_));
+  return (new PPB_Flash_NetConnector_Impl(instance_))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateFlashTCPSocket(
     PP_Instance instance) {
   // Creating TCP socket resource at the renderer side is not supported.
   return 0;
 }
 
 PP_Resource ResourceCreationImpl::CreateFontObject(
     PP_Instance pp_instance,
@@ skipping 95 matching lines @@
   return PPB_Surface3D_Impl::Create(instance_, config, attrib_list);
 }
 
 PP_Resource ResourceCreationImpl::CreateTransport(PP_Instance instance,
                                                   const char* name,
                                                   const char* proto) {
   return PPB_Transport_Impl::Create(instance_, name, proto);
 }
 
 PP_Resource ResourceCreationImpl::CreateURLLoader(PP_Instance instance) {
-  return ReturnResource(new PPB_URLLoader_Impl(instance_, false));
+  return (new PPB_URLLoader_Impl(instance_, false))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateURLRequestInfo(PP_Instance instance) {
-  return ReturnResource(new PPB_URLRequestInfo_Impl(instance_));
+  return (new PPB_URLRequestInfo_Impl(instance_))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateVideoCapture(PP_Instance instance) {
   scoped_refptr<PPB_VideoCapture_Impl> video_capture =
       new PPB_VideoCapture_Impl(instance_);
   if (!video_capture->Init())
     return 0;
-  return ReturnResource(video_capture);
+  return video_capture->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateVideoDecoder(
     PP_Instance instance,
     PP_Resource context3d_id,
     const PP_VideoConfigElement* config) {
   return PPB_VideoDecoder_Impl::Create(instance_, context3d_id, config);
 }
 
 PP_Resource ResourceCreationImpl::CreateVideoLayer(PP_Instance instance,
@@ skipping 14 matching lines @@
   data.event_modifiers = modifiers;
   data.wheel_delta = *wheel_delta;
   data.wheel_ticks = *wheel_ticks;
   data.wheel_scroll_by_page = PP_ToBool(scroll_by_page);
 
   return PPB_InputEvent_Impl::Create(instance_, data);
 }
 
 }  // namespace ppapi
 }  // namespace webkit