Convert Chrome PPAPI proxy from bool to PP_Bool.

ppapi/proxy/ppb_image_data_proxy.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 "ppapi/proxy/ppb_image_data_proxy.h"
 
 #include <string.h>  // For memcpy
 
 #include <vector>
 
@@ skipping 76 matching lines @@
 namespace {
 
 PP_ImageDataFormat GetNativeImageDataFormat() {
   int32 format = 0;
   PluginDispatcher::Get()->Send(
       new PpapiHostMsg_PPBImageData_GetNativeImageDataFormat(
           INTERFACE_ID_PPB_IMAGE_DATA, &format));
   return static_cast<PP_ImageDataFormat>(format);
 }
 
-bool IsImageDataFormatSupported(PP_ImageDataFormat format) {
-  bool supported = false;
+PP_Bool IsImageDataFormatSupported(PP_ImageDataFormat format) {
+  PP_Bool supported = PP_FALSE;
   PluginDispatcher::Get()->Send(
       new PpapiHostMsg_PPBImageData_IsImageDataFormatSupported(
           INTERFACE_ID_PPB_IMAGE_DATA, static_cast<int32_t>(format),
           &supported));
   return supported;
 }
 
 PP_Resource Create(PP_Module module_id,
                    PP_ImageDataFormat format,
                    const PP_Size* size,
-                   bool init_to_zero) {
+                   PP_Bool init_to_zero) {
   PP_Resource result = 0;
   std::string image_data_desc;
   uint64_t shm_handle = -1;
   PluginDispatcher::Get()->Send(
       new PpapiHostMsg_PPBImageData_Create(
           INTERFACE_ID_PPB_IMAGE_DATA, module_id, format, *size, init_to_zero,
           &result, &image_data_desc, &shm_handle));
 
   if (result && image_data_desc.size() == sizeof(PP_ImageDataDesc)) {
     // We serialize the PP_ImageDataDesc just by copying to a string.
     PP_ImageDataDesc desc;
     memcpy(&desc, image_data_desc.data(), sizeof(PP_ImageDataDesc));
 
     linked_ptr<ImageData> object(
         new ImageData(desc, shm_handle));
     PluginDispatcher::Get()->plugin_resource_tracker()->AddResource(
         result, object);
   }
   return result;
 }
 
-bool IsImageData(PP_Resource resource) {
+PP_Bool IsImageData(PP_Resource resource) {
   ImageData* object = PluginResource::GetAs<ImageData>(resource);
-  return !!object;
+  return BoolToPPBool(!!object);
 }
 
-bool Describe(PP_Resource resource, PP_ImageDataDesc* desc) {
+PP_Bool Describe(PP_Resource resource, PP_ImageDataDesc* desc) {
   ImageData* object = PluginResource::GetAs<ImageData>(resource);
   if (!object)
-    return false;
+    return PP_FALSE;
   memcpy(desc, &object->desc(), sizeof(PP_ImageDataDesc));
-  return true;
+  return PP_TRUE;
 }
 
 void* Map(PP_Resource resource) {
   ImageData* object = PluginResource::GetAs<ImageData>(resource);
   if (!object)
     return NULL;
   return object->Map();
 }
 
 void Unmap(PP_Resource resource) {
@@ skipping 39 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBImageData_Create, OnMsgCreate)
   IPC_END_MESSAGE_MAP()
   // FIXME(brettw) handle bad messages!
 }
 
 void PPB_ImageData_Proxy::OnMsgGetNativeImageDataFormat(int32* result) {
   *result = ppb_image_data_target()->GetNativeImageDataFormat();
 }
 
 void PPB_ImageData_Proxy::OnMsgIsImageDataFormatSupported(int32 format,
-                                                          bool* result) {
+                                                          PP_Bool* result) {
   *result = ppb_image_data_target()->IsImageDataFormatSupported(
       static_cast<PP_ImageDataFormat>(format));
 }
 
 void PPB_ImageData_Proxy::OnMsgCreate(PP_Module module,
                                       int32_t format,
                                       const PP_Size& size,
-                                      bool init_to_zero,
+                                      PP_Bool init_to_zero,
                                       PP_Resource* result,
                                       std::string* image_data_desc,
                                       uint64_t* result_shm_handle) {
   *result = ppb_image_data_target()->Create(
       module, static_cast<PP_ImageDataFormat>(format), &size, init_to_zero);
   *result_shm_handle = 0;
   if (*result) {
     // The ImageDesc is just serialized as a string.
     PP_ImageDataDesc desc;
     if (ppb_image_data_target()->Describe(*result, &desc)) {
       image_data_desc->resize(sizeof(PP_ImageDataDesc));
       memcpy(&(*image_data_desc)[0], &desc, sizeof(PP_ImageDataDesc));
     }
 
     // Get the shared memory handle.
     const PPB_ImageDataTrusted* trusted =
         reinterpret_cast<const PPB_ImageDataTrusted*>(
             dispatcher()->GetLocalInterface(PPB_IMAGEDATA_TRUSTED_INTERFACE));
     if (trusted)
       *result_shm_handle = trusted->GetNativeMemoryHandle(*result);
   }
 }
 
 }  // namespace proxy
 }  // namespace pp