[PPAPI] Added PP_VARTYPE_RESOURCE as a PP_VarType enum value.

ppapi/shared_impl/unittest_utils.cc

Index: ppapi/shared_impl/unittest_utils.cc
diff --git a/ppapi/shared_impl/unittest_utils.cc b/ppapi/shared_impl/unittest_utils.cc
index f5d064b4db669e0ad939a55ebfca05cb2ce99ab0..f613882dde54291c30c4b2ed2e8249a88961aecf 100644
--- a/ppapi/shared_impl/unittest_utils.cc
+++ b/ppapi/shared_impl/unittest_utils.cc
@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
+#include "ppapi/shared_impl/resource_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 
@@ -151,6 +152,39 @@ bool Equals(const PP_Var& expected,
       }
       return true;
     }
+    case PP_VARTYPE_RESOURCE: {
+      ResourceVar* expected_var = ResourceVar::FromPPVar(expected);
+      ResourceVar* actual_var = ResourceVar::FromPPVar(actual);
+      DCHECK(expected_var && actual_var);
+      if (expected_var->pp_resource() != actual_var->pp_resource()) {
+        LOG(ERROR) << "expected: " << expected_var->pp_resource() << " actual: "
+                   << actual_var->pp_resource();
+        return false;
+      }
+      IPC::Message actual_message(actual_var->creation_message());
+      const IPC::Message& expected_message = expected_var->creation_message();
+      if (expected_message.size() != actual_message.size()) {
+        LOG(ERROR) << "expected creation message size: "
+                   << expected_message.size() << " actual: "
+                   << actual_message.size();
+        return false;
+      }
+
+      // Set the upper 24 bits of actual creation_message flags to the same as
+      // expected. This is an unpredictable reference number that changes
+      // between serialization/deserialization, and we do not want it to cause
+      // the comparison to fail.
+      actual_message.SetHeaderValues(actual_message.routing_id(),
+                                     actual_message.type(),
+                                     (expected_message.flags() & 0xffffff00) |
+                                      (actual_message.flags() & 0xff));
+      if (memcmp(expected_message.data(), actual_message.data(),
+                 expected_message.size()) != 0) {

[dmichael (off chromium), 2013/09/11 18:30:05]

Why not just memcmp the data that is expected to be equal, rather than mutating
actual_message?
I.e.:
DCHECK(expected_message.size() >= 3);
memcmp(expected_message.data()+3, actual_message.data()+3,
       expected_message.size()-3)

[Matt Giuca, 2013/09/12 07:08:24]

That would assume implementation details about the message format (i.e., that
the flags are stored in a certain place in the header, that there is a certain
endianness, the size of all fields preceding the flags, the order the compiler
chooses to place them in the struct). Note that it wouldn't be 3 bytes to skip,
but I believe 32. You would also then ignore all the information in the other
header fields, including the message type.

It is much safer to stomp out the field using the interface provided (although
even here I am assuming the implementation detail that the reference number is
in the top 24 bits; but I don't have much choice). Note that I am not mutating
the input message -- I make a copy of it on line 164 so this mutation doesn't
leak any side effects.

+        LOG(ERROR) << "expected creation message does not match actual.";
+        return false;
+      }
+      return true;
+    }
   }
   NOTREACHED();
   return false;