Remove webkit::ppapi::Resource.

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 {
 
-ResourceCreationImpl::ResourceCreationImpl(PluginInstance* instance)
-    : instance_(instance) {
+ResourceCreationImpl::ResourceCreationImpl(PluginInstance* instance) {
 }
 
 ResourceCreationImpl::~ResourceCreationImpl() {
 }
 
 ::ppapi::thunk::ResourceCreationAPI*
 ResourceCreationImpl::AsResourceCreationAPI() {
   return this;
 }
 
 PP_Resource ResourceCreationImpl::CreateAudio(
-    PP_Instance instance_id,
+    PP_Instance instance,
     PP_Resource config_id,
     PPB_Audio_Callback audio_callback,
     void* user_data) {
-  return PPB_Audio_Impl::Create(instance_, config_id, audio_callback,
+  return PPB_Audio_Impl::Create(instance, config_id, audio_callback,
                                 user_data);
 }
 
 PP_Resource ResourceCreationImpl::CreateAudioConfig(
-    PP_Instance instance_id,
+    PP_Instance instance,
     PP_AudioSampleRate sample_rate,
     uint32_t sample_frame_count) {
-  return PPB_AudioConfig_Impl::Create(instance_, sample_rate,
+  return PPB_AudioConfig_Impl::Create(instance, sample_rate,
                                        sample_frame_count);
 }
 
 PP_Resource ResourceCreationImpl::CreateAudioTrusted(
-    PP_Instance instance_id) {
-  return (new PPB_Audio_Impl(instance_))->GetReference();
+    PP_Instance instance) {
+  return (new PPB_Audio_Impl(instance))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateBroker(PP_Instance instance) {
-  return (new PPB_Broker_Impl(instance_))->GetReference();
+  return (new PPB_Broker_Impl(instance))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateBuffer(PP_Instance instance,
                                                uint32_t size) {
-  return PPB_Buffer_Impl::Create(instance_, size);
+  return PPB_Buffer_Impl::Create(instance, size);
 }
 
 PP_Resource ResourceCreationImpl::CreateContext3D(
     PP_Instance instance,
     PP_Config3D_Dev config,
     PP_Resource share_context,
     const int32_t* attrib_list) {
   return PPB_Context3D_Impl::Create(instance, config, share_context,
                                     attrib_list);
 }
 
 PP_Resource ResourceCreationImpl::CreateContext3DRaw(
     PP_Instance instance,
     PP_Config3D_Dev config,
     PP_Resource share_context,
     const int32_t* attrib_list) {
   return PPB_Context3D_Impl::CreateRaw(instance, config, share_context,
                                        attrib_list);
 }
 
 PP_Resource ResourceCreationImpl::CreateDirectoryReader(
     PP_Resource directory_ref) {
   return PPB_DirectoryReader_Impl::Create(directory_ref);
 }
 
 PP_Resource ResourceCreationImpl::CreateFileChooser(
     PP_Instance instance,
     PP_FileChooserMode_Dev mode,
     const PP_Var& accept_mime_types) {
-  return PPB_FileChooser_Impl::Create(instance_, mode, accept_mime_types);
+  return PPB_FileChooser_Impl::Create(instance, mode, accept_mime_types);
 }
 
 PP_Resource ResourceCreationImpl::CreateFileIO(PP_Instance instance) {
-  return (new PPB_FileIO_Impl(instance_))->GetReference();
+  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);
+  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);
+  return PPB_Flash_Menu_Impl::Create(instance, menu_data);
 }
 
 PP_Resource ResourceCreationImpl::CreateFlashNetConnector(
     PP_Instance instance) {
-  return (new PPB_Flash_NetConnector_Impl(instance_))->GetReference();
+  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,
+    PP_Instance instance,
     const PP_FontDescription_Dev* description) {
-  return PPB_Font_Impl::Create(instance_, *description);
+  return PPB_Font_Impl::Create(instance, *description);
 }
 
 PP_Resource ResourceCreationImpl::CreateGraphics2D(
-    PP_Instance pp_instance,
+    PP_Instance instance,
     const PP_Size& size,
     PP_Bool is_always_opaque) {
-  return PPB_Graphics2D_Impl::Create(instance_, size, is_always_opaque);
+  return PPB_Graphics2D_Impl::Create(instance, size, is_always_opaque);
 }
 
 PP_Resource ResourceCreationImpl::CreateGraphics3D(
     PP_Instance instance,
     PP_Resource share_context,
     const int32_t* attrib_list) {
-  return PPB_Graphics3D_Impl::Create(instance_, share_context, attrib_list);
+  return PPB_Graphics3D_Impl::Create(instance, share_context, attrib_list);
 }
 
 PP_Resource ResourceCreationImpl::CreateGraphics3DRaw(
     PP_Instance instance,
     PP_Resource share_context,
     const int32_t* attrib_list) {
-  return PPB_Graphics3D_Impl::CreateRaw(instance_, share_context, attrib_list);
+  return PPB_Graphics3D_Impl::CreateRaw(instance, share_context, attrib_list);
 }
 
-PP_Resource ResourceCreationImpl::CreateImageData(PP_Instance pp_instance,
+PP_Resource ResourceCreationImpl::CreateImageData(PP_Instance instance,
                                                   PP_ImageDataFormat format,
                                                   const PP_Size& size,
                                                   PP_Bool init_to_zero) {
-  return PPB_ImageData_Impl::Create(instance_, format, size, init_to_zero);
+  return PPB_ImageData_Impl::Create(instance, format, size, init_to_zero);
 }
 
 PP_Resource ResourceCreationImpl::CreateKeyboardInputEvent(
     PP_Instance instance,
     PP_InputEvent_Type type,
     PP_TimeTicks time_stamp,
     uint32_t modifiers,
     uint32_t key_code,
     struct PP_Var character_text) {
   if (type != PP_INPUTEVENT_TYPE_RAWKEYDOWN &&
       type != PP_INPUTEVENT_TYPE_KEYDOWN &&
       type != PP_INPUTEVENT_TYPE_KEYUP &&
       type != PP_INPUTEVENT_TYPE_CHAR)
     return 0;
 
   InputEventData data;
   data.event_type = type;
   data.event_time_stamp = time_stamp;
   data.event_modifiers = modifiers;
   data.key_code = key_code;
   if (character_text.type == PP_VARTYPE_STRING) {
     StringVar* string_var = StringVar::FromPPVar(character_text);
     if (!string_var)
       return 0;
     data.character_text = string_var->value();
   }
 
-  return PPB_InputEvent_Impl::Create(instance_, data);
+  return (new PPB_InputEvent_Impl(instance, data))->GetReference();

[viettrungluu, 2011/08/23 17:28:13]

I don't know how I feel about the use of the result of |new ...| as the LHS to
->. I guess it's not illegal.

 }
 
 PP_Resource ResourceCreationImpl::CreateMouseInputEvent(
     PP_Instance instance,
     PP_InputEvent_Type type,
     PP_TimeTicks time_stamp,
     uint32_t modifiers,
     PP_InputEvent_MouseButton mouse_button,
     const PP_Point* mouse_position,
     int32_t click_count) {
   if (type != PP_INPUTEVENT_TYPE_MOUSEDOWN &&
       type != PP_INPUTEVENT_TYPE_MOUSEUP &&
       type != PP_INPUTEVENT_TYPE_MOUSEMOVE &&
       type != PP_INPUTEVENT_TYPE_MOUSEENTER &&
       type != PP_INPUTEVENT_TYPE_MOUSELEAVE)
     return 0;
 
   InputEventData data;
   data.event_type = type;
   data.event_time_stamp = time_stamp;
   data.event_modifiers = modifiers;
   data.mouse_button = mouse_button;
   data.mouse_position = *mouse_position;
   data.mouse_click_count = click_count;
 
-  return PPB_InputEvent_Impl::Create(instance_, data);
+  return (new PPB_InputEvent_Impl(instance, data))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateScrollbar(PP_Instance instance,
                                                   PP_Bool vertical) {
-  return PPB_Scrollbar_Impl::Create(instance_, PP_ToBool(vertical));
+  return PPB_Scrollbar_Impl::Create(instance, PP_ToBool(vertical));
 }
 
 PP_Resource ResourceCreationImpl::CreateSurface3D(
     PP_Instance instance,
     PP_Config3D_Dev config,
     const int32_t* attrib_list) {
-  return PPB_Surface3D_Impl::Create(instance_, config, attrib_list);
+  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);
+  return PPB_Transport_Impl::Create(instance, name, proto);
 }
 
 PP_Resource ResourceCreationImpl::CreateURLLoader(PP_Instance instance) {
-  return (new PPB_URLLoader_Impl(instance_, false))->GetReference();
+  return (new PPB_URLLoader_Impl(instance, false))->GetReference();
 }
 
 PP_Resource ResourceCreationImpl::CreateURLRequestInfo(PP_Instance instance) {
-  return (new PPB_URLRequestInfo_Impl(instance_))->GetReference();
+  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_);
+      new PPB_VideoCapture_Impl(instance);
   if (!video_capture->Init())
     return 0;
   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);
+  return PPB_VideoDecoder_Impl::Create(instance, context3d_id, config);
 }
 
 PP_Resource ResourceCreationImpl::CreateVideoLayer(PP_Instance instance,
                                                    PP_VideoLayerMode_Dev mode) {
-  return PPB_VideoLayer_Impl::Create(instance_, mode);
+  return PPB_VideoLayer_Impl::Create(instance, mode);
 }
 
 PP_Resource ResourceCreationImpl::CreateWheelInputEvent(
     PP_Instance instance,
     PP_TimeTicks time_stamp,
     uint32_t modifiers,
     const PP_FloatPoint* wheel_delta,
     const PP_FloatPoint* wheel_ticks,
     PP_Bool scroll_by_page) {
   InputEventData data;
   data.event_type = PP_INPUTEVENT_TYPE_WHEEL;
   data.event_time_stamp = time_stamp;
   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);
+  return (new PPB_InputEvent_Impl(instance, data))->GetReference();
 }
 
 }  // namespace ppapi
 }  // namespace webkit