Rename InterfaceID to ApiID and move the file.

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 160 matching lines @@
 
   for (std::set<int>::iterator i = pending_requests_for_filter_.begin();
        i != pending_requests_for_filter_.end(); ++i) {
     g_module_local_thread_adapter->OnModuleLocalMessageFailed(*i);
   }
 }
 
 bool ModuleLocalThreadAdapter::Filter::OnMessageReceived(
     const IPC::Message& message) {
   if (!message.is_reply() ||
-      message.routing_id() != INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL)
+      message.routing_id() != API_ID_PPB_FLASH_FILE_MODULELOCAL)
     return false;
 
   if (g_module_local_thread_adapter->OnModuleLocalMessageReceived(message)) {
     // The message was consumed, this means we can remove the message ID from
     // the list of messages this channel is waiting on.
     pending_requests_for_filter_.erase(IPC::SyncMessage::GetMessageId(message));
     return true;
   }
   return false;
 }
@@ skipping 200 matching lines @@
                             const char* path,
                             int32_t mode,
                             PP_FileHandle* file) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   IPC::PlatformFileForTransit transit;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_OpenFile(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
+          API_ID_PPB_FLASH_FILE_MODULELOCAL,
           instance, path, mode, &transit, &result));
   *file = IPC::PlatformFileForTransitToPlatformFile(transit);
   return result;
 }
 
 int32_t RenameModuleLocalFile(PP_Instance instance,
                               const char* from_path,
                               const char* to_path) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_RenameFile(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
+          API_ID_PPB_FLASH_FILE_MODULELOCAL,
           instance, from_path, to_path, &result));
   return result;
 }
 
 int32_t DeleteModuleLocalFileOrDir(PP_Instance instance,
                                    const char* path,
                                    PP_Bool recursive) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_DeleteFileOrDir(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
+          API_ID_PPB_FLASH_FILE_MODULELOCAL,
           instance, path, recursive, &result));
   return result;
 }
 
 int32_t CreateModuleLocalDir(PP_Instance instance, const char* path) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_CreateDir(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL, instance, path, &result));
+          API_ID_PPB_FLASH_FILE_MODULELOCAL, instance, path, &result));
   return result;
 }
 
 int32_t QueryModuleLocalFile(PP_Instance instance,
                              const char* path,
                              PP_FileInfo* info) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_QueryFile(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL, instance, path,
+          API_ID_PPB_FLASH_FILE_MODULELOCAL, instance, path,
           info, &result));
   return result;
 }
 
 int32_t GetModuleLocalDirContents(PP_Instance instance,
                                   const char* path,
                                   PP_DirContents_Dev** contents) {
   if (!g_module_local_thread_adapter)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   std::vector<SerializedDirEntry> entries;
   g_module_local_thread_adapter->Send(instance,
       new PpapiHostMsg_PPBFlashFile_ModuleLocal_GetDirContents(
-          INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
+          API_ID_PPB_FLASH_FILE_MODULELOCAL,
           instance, path, &entries, &result));
 
   if (result != PP_OK)
     return result;
 
   // Copy the serialized dir entries to the output struct.
   *contents = new PP_DirContents_Dev;
   (*contents)->count = static_cast<int32_t>(entries.size());
   (*contents)->entries = new PP_DirEntry_Dev[entries.size()];
   for (size_t i = 0; i < entries.size(); i++) {
@@ skipping 40 matching lines @@
 }
 
 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,
-    INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
+    API_ID_PPB_FLASH_FILE_MODULELOCAL,
     true,
     &CreateFlashFileModuleLocalProxy,
   };
   return &info;
 }
 
 bool PPB_Flash_File_ModuleLocal_Proxy::OnMessageReceived(
     const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_File_ModuleLocal_Proxy, msg)
@@ skipping 93 matching lines @@
   if (!file_ref)
     return PP_ERROR_BADRESOURCE;
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(file_ref);
   if (!dispatcher)
     return PP_ERROR_BADARGUMENT;
 
   int32_t result = PP_ERROR_FAILED;
   IPC::PlatformFileForTransit transit;
   dispatcher->Send(new PpapiHostMsg_PPBFlashFile_FileRef_OpenFile(
-      INTERFACE_ID_PPB_FLASH_FILE_FILEREF,
+      API_ID_PPB_FLASH_FILE_FILEREF,
       file_ref->host_resource(), mode, &transit, &result));
   *file = IPC::PlatformFileForTransitToPlatformFile(transit);
   return result;
 }
 
 int32_t QueryFileRefFile(PP_Resource file_ref_id,
                          PP_FileInfo* info) {
   Resource* file_ref =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(file_ref_id);
   if (!file_ref)
     return PP_ERROR_BADRESOURCE;
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(file_ref);
   if (!dispatcher)
     return PP_ERROR_BADARGUMENT;
 
   int32_t result = PP_ERROR_FAILED;
   dispatcher->Send(new PpapiHostMsg_PPBFlashFile_FileRef_QueryFile(
-      INTERFACE_ID_PPB_FLASH_FILE_FILEREF,
+      API_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) {
@@ skipping 13 matching lines @@
 }
 
 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,
-    INTERFACE_ID_PPB_FLASH_FILE_FILEREF,
+    API_ID_PPB_FLASH_FILE_FILEREF,
     true,
     &CreateFlashFileFileRefProxy,
   };
   return &info;
 }
 
 bool PPB_Flash_File_FileRef_Proxy::OnMessageReceived(
     const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_File_FileRef_Proxy, msg)
@@ skipping 22 matching lines @@
 void PPB_Flash_File_FileRef_Proxy::OnMsgQueryFile(
     const HostResource& host_resource,
     PP_FileInfo* info,
     int32_t* result) {
   *result = ppb_flash_file_fileref_impl_->QueryFile(
       host_resource.host_resource(), info);
 }
 
 }  // namespace proxy
 }  // namespace ppapi