[PPAPI] Added PP_VARTYPE_RESOURCE as a PP_VarType enum value.

ppapi/shared_impl/unittest_utils.cc

 // Copyright (c) 2013 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/shared_impl/unittest_utils.h"
 
 #include <cmath>
 
 #include "base/containers/hash_tables.h"
 #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"
 
 namespace ppapi {
 
 namespace {
 
 // When two vars x and y are found to be equal, an entry is inserted into
 // |visited_map| with (x.value.as_id, y.value.as_id). This allows reference
 // cycles to be avoided. It also allows us to associate nodes in |expected| with
@@ skipping 121 matching lines @@
           return false;
         }
         if (!Equals(expected_iter->second.get(),
                     actual_iter->second.get(),
                     visited_map)) {
           return false;
         }
       }
       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;
 }
 
 }  // namespace
 
 bool TestEqual(const PP_Var& expected, const PP_Var& actual) {
   base::hash_map<int64_t, int64_t> visited_map;
   return Equals(expected, actual, &visited_map);
 }
 
 }  // namespace ppapi