Use macros to define pepper interfaces

ppapi/proxy/ppb_flash_file_proxy.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 "ppapi/proxy/ppb_flash_file_proxy.h"
 
 #include <map>
 #include <set>
 #include <vector>
 
@@ skipping 483 matching lines @@
   &ClearThreadAdapterForInstance,
   &OpenModuleLocalFile,
   &RenameModuleLocalFile,
   &DeleteModuleLocalFileOrDir,
   &CreateModuleLocalDir,
   &QueryModuleLocalFile,
   &GetModuleLocalDirContents,
   &FreeDirContents,
 };
 
-InterfaceProxy* CreateFlashFileModuleLocalProxy(Dispatcher* dispatcher,
-                                                const void* target_interface) {
-  return new PPB_Flash_File_ModuleLocal_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreateFlashFileModuleLocalProxy(Dispatcher* dispatcher) {
+  return new PPB_Flash_File_ModuleLocal_Proxy(dispatcher);
 }
 
 }  // namespace
 
 PPB_Flash_File_ModuleLocal_Proxy::PPB_Flash_File_ModuleLocal_Proxy(
-    Dispatcher* dispatcher,
-    const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      ppb_flash_file_module_local_impl_(NULL) {
+  if (!dispatcher->IsPlugin()) {
+    ppb_flash_file_module_local_impl_ =
+        static_cast<const PPB_Flash_File_ModuleLocal*>(
+            dispatcher->local_get_interface()(
+                PPB_FLASH_FILE_MODULELOCAL_INTERFACE));
+  }
 }
 
 PPB_Flash_File_ModuleLocal_Proxy::~PPB_Flash_File_ModuleLocal_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Flash_File_ModuleLocal_Proxy::GetInfo() {
   static const Info info = {
     &flash_file_modulelocal_interface,
     PPB_FLASH_FILE_MODULELOCAL_INTERFACE,
@@ skipping 26 matching lines @@
   return handled;
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgOpenFile(
     PP_Instance instance,
     const std::string& path,
     int32_t mode,
     IPC::PlatformFileForTransit* file_handle,
     int32_t* result) {
   base::PlatformFile file;
-  *result = ppb_flash_file_module_local_target()->
-      OpenFile(instance, path.c_str(), mode, &file);
+  *result = ppb_flash_file_module_local_impl_->OpenFile(
+      instance, path.c_str(), mode, &file);
   *file_handle = PlatformFileToPlatformFileForTransit(
       dispatcher(), result, file);
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgRenameFile(
     PP_Instance instance,
     const std::string& from_path,
     const std::string& to_path,
     int32_t* result) {
-  *result = ppb_flash_file_module_local_target()->
-      RenameFile(instance, from_path.c_str(), to_path.c_str());
+  *result = ppb_flash_file_module_local_impl_->RenameFile(
+      instance, from_path.c_str(), to_path.c_str());
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgDeleteFileOrDir(
     PP_Instance instance,
     const std::string& path,
     PP_Bool recursive,
     int32_t* result) {
-  *result = ppb_flash_file_module_local_target()->
-      DeleteFileOrDir(instance, path.c_str(), recursive);
+  *result = ppb_flash_file_module_local_impl_->DeleteFileOrDir(
+      instance, path.c_str(), recursive);
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgCreateDir(PP_Instance instance,
                                                       const std::string& path,
                                                       int32_t* result) {
-  *result = ppb_flash_file_module_local_target()->
-      CreateDir(instance, path.c_str());
+  *result = ppb_flash_file_module_local_impl_->CreateDir(
+      instance, path.c_str());
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgQueryFile(PP_Instance instance,
                                                       const std::string& path,
                                                       PP_FileInfo* info,
                                                       int32_t* result) {
-  *result = ppb_flash_file_module_local_target()->
-      QueryFile(instance, path.c_str(), info);
+  *result = ppb_flash_file_module_local_impl_->QueryFile(
+      instance, path.c_str(), info);
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgGetDirContents(
     PP_Instance instance,
     const std::string& path,
     std::vector<SerializedDirEntry>* entries,
     int32_t* result) {
   PP_DirContents_Dev* contents = NULL;
-  *result = ppb_flash_file_module_local_target()->
-      GetDirContents(instance, path.c_str(), &contents);
+  *result = ppb_flash_file_module_local_impl_->GetDirContents(
+      instance, path.c_str(), &contents);
   if (*result != PP_OK)
     return;
 
   // Convert the list of entries to the serialized version.
   entries->resize(contents->count);
   for (int32_t i = 0; i < contents->count; i++) {
     (*entries)[i].name.assign(contents->entries[i].name);
     (*entries)[i].is_dir = PP_ToBool(contents->entries[i].is_dir);
   }
-  ppb_flash_file_module_local_target()->FreeDirContents(instance, contents);
+  ppb_flash_file_module_local_impl_->FreeDirContents(instance, contents);
 }
 
 // PPB_Flash_File_FileRef ------------------------------------------------------
 
 namespace {
 
 int32_t OpenFileRefFile(PP_Resource file_ref_id,
                         int32_t mode,
                         PP_FileHandle* file) {
   Resource* file_ref =
@@ skipping 30 matching lines @@
       INTERFACE_ID_PPB_FLASH_FILE_FILEREF,
       file_ref->host_resource(), info, &result));
   return result;
 }
 
 const PPB_Flash_File_FileRef flash_file_fileref_interface = {
   &OpenFileRefFile,
   &QueryFileRefFile,
 };
 
-InterfaceProxy* CreateFlashFileFileRefProxy(Dispatcher* dispatcher,
-                                            const void* target_interface) {
-  return new PPB_Flash_File_FileRef_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreateFlashFileFileRefProxy(Dispatcher* dispatcher) {
+  return new PPB_Flash_File_FileRef_Proxy(dispatcher);
 }
 
 }  // namespace
 
 PPB_Flash_File_FileRef_Proxy::PPB_Flash_File_FileRef_Proxy(
-    Dispatcher* dispatcher,
-    const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      ppb_flash_file_fileref_impl_(NULL) {
+  if (!dispatcher->IsPlugin()) {
+    ppb_flash_file_fileref_impl_ = static_cast<const PPB_Flash_File_FileRef*>(
+        dispatcher->local_get_interface()(PPB_FLASH_FILE_FILEREF_INTERFACE));
+  }
 }
 
 PPB_Flash_File_FileRef_Proxy::~PPB_Flash_File_FileRef_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Flash_File_FileRef_Proxy::GetInfo() {
   static const Info info = {
     &flash_file_fileref_interface,
     PPB_FLASH_FILE_FILEREF_INTERFACE,
@@ skipping 17 matching lines @@
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_Flash_File_FileRef_Proxy::OnMsgOpenFile(
     const HostResource& host_resource,
     int32_t mode,
     IPC::PlatformFileForTransit* file_handle,
     int32_t* result) {
   base::PlatformFile file;
-  *result = ppb_flash_file_module_local_target()->
-      OpenFile(host_resource.host_resource(), mode, &file);
+  *result = ppb_flash_file_fileref_impl_->OpenFile(
+      host_resource.host_resource(), mode, &file);
   *file_handle = PlatformFileToPlatformFileForTransit(
       dispatcher(), result, file);
 }
 
 void PPB_Flash_File_FileRef_Proxy::OnMsgQueryFile(
     const HostResource& host_resource,
     PP_FileInfo* info,
     int32_t* result) {
-  *result = ppb_flash_file_module_local_target()->
-      QueryFile(host_resource.host_resource(), info);
+  *result = ppb_flash_file_fileref_impl_->QueryFile(
+      host_resource.host_resource(), info);
 }
 
 }  // namespace proxy
 }  // namespace ppapi