Update base/tools_sanity_unittest.cc to cover MSan.

base/tools_sanity_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.
 //
 // This file contains intentional memory errors, some of which may lead to
 // crashes if the test is ran without special memory testing tools. We use these
 // errors to verify the sanity of the tools.
 
 #include "base/atomicops.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 14 matching lines @@
 // EXPECT_DEATH is not supported on IOS.
 #define HARMFUL_ACCESS(action,error_regexp) do { action; } while (0)
 #else
 #define HARMFUL_ACCESS(action,error_regexp) EXPECT_DEATH(action,error_regexp)
 #endif  // !OS_IOS
 #else
 #define HARMFUL_ACCESS(action,error_regexp) \
 do { if (RunningOnValgrind()) { action; } } while (0)
 #endif
 
-void ReadUninitializedValue(char *ptr) {
+void DoReadUninitializedValue(char *ptr) {
   // Comparison with 64 is to prevent clang from optimizing away the
   // jump -- valgrind only catches jumps and conditional moves, but clang uses
   // the borrow flag if the condition is just `*ptr == '\0'`.
   if (*ptr == 64) {
-    (*ptr)++;
+    VLOG(1) << "Uninit condition is true";

[Nico, 2014/01/15 17:46:18]

why this change?

   } else {
-    (*ptr)--;
+    VLOG(1) << "Uninit condition is false";
   }
 }
 
+void ReadUninitializedValue(char *ptr) {
+#if defined(MEMORY_SANITIZER)
+  EXPECT_DEATH(DoReadUninitializedValue(ptr),
+               "use-of-uninitialized-value");
+#else
+  DoReadUninitializedValue(ptr);
+#endif
+}
+
 void ReadValueOutOfArrayBoundsLeft(char *ptr) {
   char c = ptr[-2];
   VLOG(1) << "Reading a byte out of bounds: " << c;
 }
 
 void ReadValueOutOfArrayBoundsRight(char *ptr, size_t size) {
   char c = ptr[size + 1];
   VLOG(1) << "Reading a byte out of bounds: " << c;
 }
 
@@ skipping 209 matching lines @@
 
 TEST(ToolsSanityTest, AtomicsAreIgnored) {
   base::subtle::Atomic32 shared = 0;
   ReleaseStoreThread thread1(&shared);
   AcquireLoadThread thread2(&shared);
   RunInParallel(&thread1, &thread2);
   EXPECT_EQ(kMagicValue, shared);
 }
 
 }  // namespace base