Add async trace events to trace progress of IPC messages

chrome/nacl/nacl_ipc_adapter_unittest.cc

 // Copyright (c) 2012 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 "chrome/nacl/nacl_ipc_adapter.h"
 
 #include <string.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 74 matching lines @@
 
   int bytes_read = BlockingReceive(buf, kBufSize);
   EXPECT_EQ(sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int),
             static_cast<size_t>(bytes_read));
 
   const NaClIPCAdapter::NaClMessageHeader* output_header =
       reinterpret_cast<const NaClIPCAdapter::NaClMessageHeader*>(buf);
   EXPECT_EQ(sizeof(int), output_header->payload_size);
   EXPECT_EQ(routing_id, output_header->routing);
   EXPECT_EQ(type, output_header->type);
+  uint32 flags_mask =
+      IPC::Message::PRIORITY_MASK |

[Mark Seaborn, 2012/09/04 18:39:31]

If someone adds a flag (maybe after removing a flag or changing the
apportionment between the flags and reference number), they're likely not to
know to add it here, so the test would become weaker.

Maybe add an ALL_FLAGS_MASK to ipc_message.h or add a getter function that
extracts the flags?

[jbates, 2012/09/04 20:02:18]

It looks like this test just needs to verify that flags goes through unchanged,
right? I changed the test to get the flags member after constructing the
Message, and then check it afterwards. PTAL.

+      IPC::Message::SYNC_BIT |
+      IPC::Message::REPLY_BIT |
+      IPC::Message::REPLY_ERROR_BIT |
+      IPC::Message::UNBLOCK_BIT |
+      IPC::Message::PUMPING_MSGS_BIT |
+      IPC::Message::HAS_SENT_TIME_BIT;
   EXPECT_EQ(static_cast<uint32>(IPC::Message::PRIORITY_NORMAL),
-            output_header->flags);
+            static_cast<uint32>(output_header->flags & flags_mask));
   EXPECT_EQ(0u, output_header->num_fds);
   EXPECT_EQ(0u, output_header->pad);
 
   // Validate the payload.
   EXPECT_EQ(value,
             *reinterpret_cast<const int*>(&buf[
                 sizeof(NaClIPCAdapter::NaClMessageHeader)]));
 }
 
 // Tests a simple message getting rewritten sent from NaCl to native code.
@@ skipping 192 matching lines @@
   EXPECT_EQ(-1, result);
 
   // Test the "previously had an error" case. BlockingReceive should return
   // immediately if there was an error.
   result = BlockingReceive(buf, kBufSize);
   EXPECT_EQ(-1, result);
 
   thread.Join();
 }