Make TracedValue lower overhead.

base/pickle_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 <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const int testint = 2093847192;
 const std::string teststr("Hello world");  // note non-aligned string length
 const std::wstring testwstr(L"Hello, world");
 const char testdata[] = "AAA\0BBB\0";
 const int testdatalen = arraysize(testdata) - 1;
 const bool testbool1 = false;
 const bool testbool2 = true;
 const uint16 testuint16 = 32123;
+const uintptr_t testuintptr_t = 42;
 const float testfloat = 3.1415926935f;
 
 // checks that the result
 void VerifyResult(const Pickle& pickle) {
   PickleIterator iter(pickle);
 
   int outint;
   EXPECT_TRUE(pickle.ReadInt(&iter, &outint));
   EXPECT_EQ(testint, outint);
 
   std::string outstr;
   EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
   EXPECT_EQ(teststr, outstr);
 
   std::wstring outwstr;
   EXPECT_TRUE(pickle.ReadWString(&iter, &outwstr));
   EXPECT_EQ(testwstr, outwstr);
 
   bool outbool;
   EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
   EXPECT_FALSE(outbool);
   EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
   EXPECT_TRUE(outbool);
 
   uint16 outuint16;
   EXPECT_TRUE(pickle.ReadUInt16(&iter, &outuint16));
   EXPECT_EQ(testuint16, outuint16);
 
+  uintptr_t outuintptr_t;
+  EXPECT_TRUE(pickle.ReadUIntPtr(&iter, &outuintptr_t));
+  EXPECT_EQ(testuintptr_t, outuintptr_t);
+
   float outfloat;
   EXPECT_TRUE(pickle.ReadFloat(&iter, &outfloat));
   EXPECT_EQ(testfloat, outfloat);
 
   const char* outdata;
   int outdatalen;
   EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
   EXPECT_EQ(testdatalen, outdatalen);
   EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
 
   EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
   EXPECT_EQ(testdatalen, outdatalen);
   EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
 
   // reads past the end should fail
   EXPECT_FALSE(pickle.ReadInt(&iter, &outint));
 }
 
 }  // namespace
 
 TEST(PickleTest, EncodeDecode) {
   Pickle pickle;
 
   EXPECT_TRUE(pickle.WriteInt(testint));
   EXPECT_TRUE(pickle.WriteString(teststr));
   EXPECT_TRUE(pickle.WriteWString(testwstr));
   EXPECT_TRUE(pickle.WriteBool(testbool1));
   EXPECT_TRUE(pickle.WriteBool(testbool2));
   EXPECT_TRUE(pickle.WriteUInt16(testuint16));
+  EXPECT_TRUE(pickle.WriteUIntPtr(testuintptr_t));
   EXPECT_TRUE(pickle.WriteFloat(testfloat));
   EXPECT_TRUE(pickle.WriteData(testdata, testdatalen));
 
   // Over allocate BeginWriteData so we can test TrimWriteData.
   char* dest = pickle.BeginWriteData(testdatalen + 100);
   EXPECT_TRUE(dest);
   memcpy(dest, testdata, testdatalen);
 
   pickle.TrimWriteData(testdatalen);
 
@@ skipping 243 matching lines @@
   EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data)));
 
   PickleIterator iter(pickle);
   const char* outdata_char = NULL;
   EXPECT_TRUE(pickle.ReadBytes(&iter, &outdata_char, sizeof(data)));
 
   int outdata;
   memcpy(&outdata, outdata_char, sizeof(outdata));
   EXPECT_EQ(data, outdata);
 }