Convert Chrome PPAPI proxy from bool to PP_Bool.

ppapi/proxy/ppb_graphics_2d_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_graphics_2d_proxy.h"
 
 #include <string.h>  // For memset
 
 #include "base/logging.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 class Graphics2D : public PluginResource {
  public:
-  Graphics2D(const PP_Size& size, bool is_always_opaque)
+  Graphics2D(const PP_Size& size, PP_Bool is_always_opaque)
       : size_(size), is_always_opaque_(is_always_opaque) {
   }
 
   // Resource overrides.
   virtual Graphics2D* AsGraphics2D() { return this; }
 
   const PP_Size& size() const { return size_; }
-  bool is_always_opaque() const { return is_always_opaque_; }
+  PP_Bool is_always_opaque() const { return is_always_opaque_; }
 
  private:
   PP_Size size_;
-  bool is_always_opaque_;
+  PP_Bool is_always_opaque_;
 
   DISALLOW_COPY_AND_ASSIGN(Graphics2D);
 };
 
 namespace {
 
 PP_Resource Create(PP_Module module_id,
                    const PP_Size* size,
-                   bool is_always_opaque) {
+                   PP_Bool is_always_opaque) {
   PluginDispatcher* dispatcher = PluginDispatcher::Get();
   PP_Resource result = 0;
   dispatcher->Send(new PpapiHostMsg_PPBGraphics2D_Create(
       INTERFACE_ID_PPB_GRAPHICS_2D, module_id, *size, is_always_opaque,
       &result));
   if (result) {
     linked_ptr<Graphics2D> graphics_2d(new Graphics2D(*size, is_always_opaque));
     dispatcher->plugin_resource_tracker()->AddResource(result, graphics_2d);
   }
   return result;
 }
 
-bool IsGraphics2D(PP_Resource resource) {
+PP_Bool IsGraphics2D(PP_Resource resource) {
   Graphics2D* object = PluginResource::GetAs<Graphics2D>(resource);
-  return !!object;
+  return BoolToPPBool(!!object);
 }
 
-bool Describe(PP_Resource graphics_2d,
-              PP_Size* size,
-              bool* is_always_opaque) {
+PP_Bool Describe(PP_Resource graphics_2d,
+                 PP_Size* size,
+                 PP_Bool* is_always_opaque) {
   Graphics2D* object = PluginResource::GetAs<Graphics2D>(graphics_2d);
   if (!object) {
     size->width = 0;
     size->height = 0;
-    *is_always_opaque = false;
-    return false;
+    *is_always_opaque = PP_FALSE;
+    return PP_FALSE;
   }
 
   *size = object->size();
   *is_always_opaque = object->is_always_opaque();
-  return true;
+  return PP_TRUE;
 }
 
 void PaintImageData(PP_Resource graphics_2d,
                     PP_Resource image_data,
                     const PP_Point* top_left,
                     const PP_Rect* src_rect) {
   PP_Rect dummy;
   memset(&dummy, 0, sizeof(PP_Rect));
   PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBGraphics2D_PaintImageData(
       INTERFACE_ID_PPB_GRAPHICS_2D, graphics_2d, image_data, *top_left,
@@ skipping 65 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_ReplaceContents,
                         OnMsgReplaceContents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Flush,
                         OnMsgFlush)
   IPC_END_MESSAGE_MAP()
   // FIXME(brettw) handle bad messages!
 }
 
 void PPB_Graphics2D_Proxy::OnMsgCreate(PP_Module module,
                                        const PP_Size& size,
-                                       bool is_always_opaque,
+                                       PP_Bool is_always_opaque,
                                        PP_Resource* result) {
   *result = ppb_graphics_2d_target()->Create(
       module, &size, is_always_opaque);
 }
 
 void PPB_Graphics2D_Proxy::OnMsgPaintImageData(PP_Resource graphics_2d,
                                                PP_Resource image_data,
                                                const PP_Point& top_left,
                                                bool src_rect_specified,
                                                const PP_Rect& src_rect) {
@@ skipping 21 matching lines @@
                                       int32_t* result) {
   // TODO(brettw) this should be a non-sync function. Ideally it would call
   // the callback with a failure code from here if you weren't allowed to
   // call Flush there.
   *result = ppb_graphics_2d_target()->Flush(
       graphics_2d, ReceiveCallback(serialized_callback));
 }
 
 }  // namespace proxy
 }  // namespace pp