Remove PPBoolToBool and BoolToPPBool and use PP_FromBool and PP_ToBool instead.

ppapi/cpp/module.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.
 
 // Note that the single accessor, Module::Get(), is not actually implemented
 // in this file.  This is an intentional hook that allows users of ppapi's
 // C++ wrapper objects to provide difference semantics for how the singleton
 // object is accessed.
 //
 // In general, users of ppapi will also link in ppp_entrypoints.cc, which
@@ skipping 12 matching lines @@
 
 #include "ppapi/cpp/module.h"
 
 #include <string.h>
 
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
-#include "ppapi/cpp/common.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/resource.h"
 #include "ppapi/cpp/url_loader.h"
 #include "ppapi/cpp/var.h"
 
 namespace pp {
 
 // PPP_InputEvent implementation -----------------------------------------------
 
 PP_Bool InputEvent_HandleEvent(PP_Instance pp_instance, PP_Resource resource) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return PP_FALSE;
   Instance* instance = module_singleton->InstanceForPPInstance(pp_instance);
   if (!instance)
     return PP_FALSE;
 
-  return BoolToPPBool(instance->HandleInputEvent(InputEvent(resource)));
+  return PP_FromBool(instance->HandleInputEvent(InputEvent(resource)));
 }
 
 const PPP_InputEvent input_event_interface = {
   &InputEvent_HandleEvent
 };
 
 // PPP_Instance implementation -------------------------------------------------
 
 PP_Bool Instance_DidCreate(PP_Instance pp_instance,
                            uint32_t argc,
                            const char* argn[],
                            const char* argv[]) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return PP_FALSE;
 
   Instance* instance = module_singleton->CreateInstance(pp_instance);
   if (!instance)
     return PP_FALSE;
   module_singleton->current_instances_[pp_instance] = instance;
-  return BoolToPPBool(instance->Init(argc, argn, argv));
+  return PP_FromBool(instance->Init(argc, argn, argv));
 }
 
 void Instance_DidDestroy(PP_Instance instance) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return;
   Module::InstanceMap::iterator found =
       module_singleton->current_instances_.find(instance);
   if (found == module_singleton->current_instances_.end())
     return;
@@ skipping 16 matching lines @@
   instance->DidChangeView(*position, *clip);
 }
 
 void Instance_DidChangeFocus(PP_Instance pp_instance, PP_Bool has_focus) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return;
   Instance* instance = module_singleton->InstanceForPPInstance(pp_instance);
   if (!instance)
     return;
-  instance->DidChangeFocus(PPBoolToBool(has_focus));
+  instance->DidChangeFocus(PP_ToBool(has_focus));
 }
 
 PP_Bool Instance_HandleInputEvent(PP_Instance pp_instance,
                                   const PP_InputEvent* event) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return PP_FALSE;
   Instance* instance = module_singleton->InstanceForPPInstance(pp_instance);
   if (!instance)
     return PP_FALSE;
-  return BoolToPPBool(instance->HandleInputEvent(*event));
+  return PP_FromBool(instance->HandleInputEvent(*event));
 }
 
 PP_Bool Instance_HandleDocumentLoad(PP_Instance pp_instance,
                                     PP_Resource pp_url_loader) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return PP_FALSE;
   Instance* instance = module_singleton->InstanceForPPInstance(pp_instance);
   if (!instance)
     return PP_FALSE;
-  return BoolToPPBool(
-      instance->HandleDocumentLoad(URLLoader(pp_url_loader)));
+  return PP_FromBool(instance->HandleDocumentLoad(URLLoader(pp_url_loader)));
 }
 
 #ifndef PPAPI_INSTANCE_REMOVE_SCRIPTING
 PP_Var Instance_GetInstanceObject(PP_Instance pp_instance) {
   Module* module_singleton = Module::Get();
   if (!module_singleton)
     return Var().Detach();
   Instance* instance = module_singleton->InstanceForPPInstance(pp_instance);
   if (!instance)
     return Var().Detach();
@@ skipping 94 matching lines @@
   const PPB_Core* core = reinterpret_cast<const PPB_Core*>(GetBrowserInterface(
       PPB_CORE_INTERFACE));
   if (!core)
     return false;
   core_ = new Core(core);
 
   return Init();
 }
 
 }  // namespace pp