Make PPAPI headers compile with C compilers (gcc on Linux & Mac and MSVS on W...

webkit/glue/plugins/pepper_video_decoder.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_video_decoder.h"
 
 #include "base/logging.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/dev/ppb_video_decoder_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
+#include "webkit/glue/plugins/pepper_common.h"
 #include "webkit/glue/plugins/pepper_file_ref.h"
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 #include "webkit/glue/plugins/pepper_resource_tracker.h"
 
 namespace pepper {
 
 namespace {
 
-bool GetConfig(PP_Instance instance_id,
+PP_Bool GetConfig(PP_Instance instance_id,
                PP_VideoCodecId_Dev codec,
                PP_VideoConfig_Dev* configs,
                int32_t config_size,
                int32_t *num_config) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   *num_config = 0;
   if (!instance)
-    return false;
+    return PP_FALSE;
 
   // Get configs based on codec.
 
   if (configs) {
     // Fill in the array of configs.
   }
 
   // Update *num_config.
 
-  return true;
+  return PP_TRUE;
 }
 
 PP_Resource Create(PP_Instance instance_id,
                    const PP_VideoDecoderConfig_Dev* decoder_config) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return 0;
 
   scoped_refptr<VideoDecoder> decoder(new VideoDecoder(instance));
 
   if (!decoder->Init(*decoder_config))
     return 0;
 
   return decoder->GetReference();
 }
 
-bool Decode(PP_Resource decoder_id,
+PP_Bool Decode(PP_Resource decoder_id,
             PP_VideoCompressedDataBuffer_Dev* input_buffer) {
   scoped_refptr<VideoDecoder> decoder(
       Resource::GetAs<VideoDecoder>(decoder_id));
   if (!decoder)
-    return false;
+    return PP_FALSE;
 
   decoder->Decode(*input_buffer);
-  return true;
+  return PP_TRUE;
 }
 
 int32_t Flush(PP_Resource decoder_id, PP_CompletionCallback callback) {
   scoped_refptr<VideoDecoder> decoder(
       Resource::GetAs<VideoDecoder>(decoder_id));
   if (!decoder)
     return PP_ERROR_BADRESOURCE;
 
   return decoder->Flush(callback);
 }
 
-bool ReturnUncompressedDataBuffer(PP_Resource decoder_id,
+PP_Bool ReturnUncompressedDataBuffer(PP_Resource decoder_id,
                                   PP_VideoUncompressedDataBuffer_Dev* buffer) {
   scoped_refptr<VideoDecoder> decoder(
       Resource::GetAs<VideoDecoder>(decoder_id));
   if (!decoder)
-    return false;
+    return PP_FALSE;
 
-  return decoder->ReturnUncompressedDataBuffer(*buffer);
+  return BoolToPPBool(decoder->ReturnUncompressedDataBuffer(*buffer));
 }
 
 const PPB_VideoDecoder_Dev ppb_videodecoder = {
   &GetConfig,
   &Create,
   &Decode,
   &Flush,
   &ReturnUncompressedDataBuffer
 };
 
@@ skipping 38 matching lines @@
 
 bool VideoDecoder::ReturnUncompressedDataBuffer(
     PP_VideoUncompressedDataBuffer_Dev& buffer) {
   if (!platform_video_decoder_.get())
     return false;
 
   return platform_video_decoder_->ReturnUncompressedDataBuffer(buffer);
 }
 
 }  // namespace pepper