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

ppapi/proxy/ppapi_param_traits.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/ppapi_param_traits.h"
 
 #include <string.h>  // For memcpy
 
-#include "ppapi/c/dev/pp_file_info_dev.h"
+#include "ppapi/c/pp_file_info.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/proxy/host_resource.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/proxy/serialized_flash_menu.h"
 
 namespace IPC {
 
 namespace {
@@ skipping 69 matching lines @@
   if (!ParamTraits<bool>::Read(m, iter, &result))
     return false;
   *r = pp::proxy::BoolToPPBool(result);
   return true;
 }
 
 // static
 void ParamTraits<PP_Bool>::Log(const param_type& p, std::string* l) {
 }
 
-// PP_FileInfo_Dev -------------------------------------------------------------
+// PP_FileInfo -------------------------------------------------------------
 
 // static
-void ParamTraits<PP_FileInfo_Dev>::Write(Message* m, const param_type& p) {
+void ParamTraits<PP_FileInfo>::Write(Message* m, const param_type& p) {
   ParamTraits<int64_t>::Write(m, p.size);
   ParamTraits<int>::Write(m, static_cast<int>(p.type));
   ParamTraits<int>::Write(m, static_cast<int>(p.system_type));
   ParamTraits<double>::Write(m, p.creation_time);
   ParamTraits<double>::Write(m, p.last_access_time);
   ParamTraits<double>::Write(m, p.last_modified_time);
 }
 
 // static
-bool ParamTraits<PP_FileInfo_Dev>::Read(const Message* m, void** iter,
+bool ParamTraits<PP_FileInfo>::Read(const Message* m, void** iter,
                                         param_type* r) {
   int type, system_type;
   if (!ParamTraits<int64_t>::Read(m, iter, &r->size) ||
       !ParamTraits<int>::Read(m, iter, &type) ||
       !ParamTraits<int>::Read(m, iter, &system_type) ||
       !ParamTraits<double>::Read(m, iter, &r->creation_time) ||
       !ParamTraits<double>::Read(m, iter, &r->last_access_time) ||
       !ParamTraits<double>::Read(m, iter, &r->last_modified_time))
     return false;
   if (type != PP_FILETYPE_REGULAR &&
       type != PP_FILETYPE_DIRECTORY &&
       type != PP_FILETYPE_OTHER)
     return false;
-  r->type = static_cast<PP_FileType_Dev>(type);
+  r->type = static_cast<PP_FileType>(type);
   if (system_type != PP_FILESYSTEMTYPE_EXTERNAL &&
       system_type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
       system_type != PP_FILESYSTEMTYPE_LOCALTEMPORARY)
     return false;
-  r->system_type = static_cast<PP_FileSystemType_Dev>(system_type);
+  r->system_type = static_cast<PP_FileSystemType>(system_type);
   return true;
 }
 
 // static
-void ParamTraits<PP_FileInfo_Dev>::Log(const param_type& p, std::string* l) {
+void ParamTraits<PP_FileInfo>::Log(const param_type& p, std::string* l) {
 }
 
 // PP_InputEvent ---------------------------------------------------------------
 
 // static
 void ParamTraits<PP_InputEvent>::Write(Message* m, const param_type& p) {
   // PP_InputEvent is just POD so we can just memcpy it.
   m->WriteData(reinterpret_cast<const char*>(&p), sizeof(PP_InputEvent));
 }
 
@@ skipping 319 matching lines @@
                                                        param_type* r) {
   return r->ReadFromMessage(m, iter);
 }
 
 // static
 void ParamTraits<pp::proxy::SerializedFlashMenu>::Log(const param_type& p,
                                                       std::string* l) {
 }
 
 }  // namespace IPC