Convert Chrome PPAPI proxy from bool to PP_Bool.

ppapi/proxy/serialized_var.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/serialized_var.h"
 
 #include "base/logging.h"
 #include "ipc/ipc_message_utils.h"
 #include "ppapi/proxy/dispatcher.h"
+#include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/proxy/var_serialization_rules.h"
 
 namespace pp {
 namespace proxy {
 
 // SerializedVar::Inner --------------------------------------------------------
 
 SerializedVar::Inner::Inner()
     : serialization_rules_(NULL),
@@ skipping 95 matching lines @@
   DCHECK(var_.type == PP_VARTYPE_STRING || string_value_.empty());
 
   m->WriteInt(static_cast<int>(var_.type));
   switch (var_.type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
       // These don't need any data associated with them other than the type we
       // just serialized.
       break;
     case PP_VARTYPE_BOOL:
       m->WriteBool(var_.value.as_bool);

[dmichael(do not use this one), 2010/11/08 15:31:19]

This part compiles okay on Windows?  I might have expected the usual
warning/error.

[brettw, 2010/11/08 15:59:19]

This doesn't build on Windows (yet), but thanks for pointing this out.

       break;
     case PP_VARTYPE_INT32:
       m->WriteInt(var_.value.as_int);
       break;
     case PP_VARTYPE_DOUBLE:
       IPC::ParamTraits<double>::Write(m, var_.value.as_double);
       break;
     case PP_VARTYPE_STRING:
       // TODO(brettw) in the case of an invalid string ID, it would be nice
       // to send something to the other side such that a 0 ID would be
@@ skipping 28 matching lines @@
     return false;
 
   bool success = false;
   switch (type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
       // These don't have any data associated with them other than the type we
       // just serialized.
       success = true;
       break;
-    case PP_VARTYPE_BOOL:
-      success = m->ReadBool(iter, &var_.value.as_bool);
+    case PP_VARTYPE_BOOL: {
+      bool bool_value;
+      success = m->ReadBool(iter, &bool_value);

[dmichael(do not use this one), 2010/11/08 15:31:19]

Maybe this would be premature optimization, but you could just serialize the
PP_Bool with a cast and WriteInt.  That's what happens to the bool value anyway,
so the current code converts enum->bool->int for serialization, and
int->bool->enum for deserialization.

[brettw, 2010/11/08 15:51:02]

The plugin might be malicious or have a bug and write a non-PP_TRUE/FALSE value
like "2". I prefer to get a correct bool value out at the renderer side to avoid
bugs. This current code will "fix" the problem when serializing, and if it's
invalid when deserializing, will report an error. Probably eventually the
deserializing error will cause us to kill the plugins since it's sending us
incorrect messages (we do this with renderers).

[dmichael(do not use this one), 2010/11/08 16:11:51]

Good point.  May warrant a comment, then, to fend off future thoughts of
inappropriate optimization?

+      var_.value.as_bool = BoolToPPBool(bool_value);
       break;
+    }
     case PP_VARTYPE_INT32:
       success = m->ReadInt(iter, &var_.value.as_int);
       break;
     case PP_VARTYPE_DOUBLE:
       success = IPC::ParamTraits<double>::Read(m, iter, &var_.value.as_double);
       break;
     case PP_VARTYPE_STRING:
       success = m->ReadString(iter, &string_value_);
       var_.value.as_id = 0;
       break;
@@ skipping 269 matching lines @@
 
 PP_Var** SerializedVarVectorOutParam::ArrayOutParam(Dispatcher* dispatcher) {
   DCHECK(!dispatcher_);  // Should only be called once.
   dispatcher_ = dispatcher;
   return &array_;
 }
 
 }  // namespace proxy
 }  // namespace pp