Migrating PPB_FileIO_Dev, PPB_FileRef_Dev, and PPB_FileSystem_Dev dependencies to PPB_FileIO, PPB...

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>
 
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_message.h"
-#include "ppapi/c/dev/pp_file_info_dev.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/c/pp_file_info.h"
 #include "ppapi/c/private/ppb_flash_file.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
@@ skipping 39 matching lines @@
 
   // Called on the I/O thread when the channel is being destroyed and the
   // given message will never be issued a reply.
   void OnModuleLocalMessageFailed(int message_id);
 
   bool Send(PP_Instance instance, IPC::Message* msg);
 
  private:
   class Filter : public IPC::ChannelProxy::MessageFilter {
    public:
-    Filter(Dispatcher* dispatcher);
+    explicit Filter(Dispatcher* dispatcher);
     ~Filter();
 
     void Send(IPC::Message* msg);
 
     virtual void OnFilterAdded(IPC::Channel* channel);
     virtual void OnFilterRemoved();
     virtual bool OnMessageReceived(const IPC::Message& message);
 
    private:
     // DO NOT DEREFERENCE! This is used only for tracking.
@@ skipping 345 matching lines @@
 
   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));
   return result;
 }
 
 int32_t QueryModuleLocalFile(PP_Instance instance,
                              const char* path,
-                             PP_FileInfo_Dev* info) {
+                             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,
           info, &result));
   return result;
 }
@@ skipping 126 matching lines @@
 
 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());
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgQueryFile(PP_Instance instance,
                                                       const std::string& path,
-                                                      PP_FileInfo_Dev* info,
+                                                      PP_FileInfo* info,
                                                       int32_t* result) {
   *result = ppb_flash_file_module_local_target()->
       QueryFile(instance, path.c_str(), info);
 }
 
 void PPB_Flash_File_ModuleLocal_Proxy::OnMsgGetDirContents(
     PP_Instance instance,
     const std::string& path,
     std::vector<pp::proxy::SerializedDirEntry>* entries,
     int32_t* result) {
@@ skipping 32 matching lines @@
   int32_t result = PP_ERROR_FAILED;
   IPC::PlatformFileForTransit transit;
   dispatcher->Send(new PpapiHostMsg_PPBFlashFile_FileRef_OpenFile(
       INTERFACE_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_Dev* info) {
+                         PP_FileInfo* info) {
   PluginResource* file_ref =
       PluginResourceTracker::GetInstance()->GetResourceObject(file_ref_id);
   if (!file_ref)
     return PP_ERROR_BADRESOURCE;
 
   PluginDispatcher* dispatcher =
       PluginDispatcher::GetForInstance(file_ref->instance());
   if (!dispatcher)
     return PP_ERROR_BADARGUMENT;
 
@@ skipping 58 matching lines @@
     int32_t* result) {
   base::PlatformFile file;
   *result = ppb_flash_file_module_local_target()->
       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_Dev* info,
+    PP_FileInfo* info,
     int32_t* result) {
   *result = ppb_flash_file_module_local_target()->
       QueryFile(host_resource.host_resource(), info);
 }
 
 }  // namespace proxy
 }  // namespace pp