Fix some purify warnings.

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 324 matching lines @@
 TEST_F(DiskCacheBackendTest, ValidEntry) {
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry1;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+  memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
   entry1->Close();
   SimulateCrash();
 
   ASSERT_TRUE(cache_->OpenEntry(key, &entry1));
 
   scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
   memset(buffer2->data(), 0, kSize);
   EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer2, kSize, NULL));
   entry1->Close();
   EXPECT_STREQ(buffer1->data(), buffer2->data());
 }
 
 // The same logic of the previous test (ValidEntry), but this time force the
 // entry to be invalid, simulating a crash in the middle.
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntry) {
   // Use the implementation directly... we need to simulate a crash.
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry1;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+  memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
   SimulateCrash();
 
   EXPECT_FALSE(cache_->OpenEntry(key, &entry1));
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 // Almost the same test, but this time crash the cache after reading an entry.
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntryRead) {
   // Use the implementation directly... we need to simulate a crash.
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry1;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+  memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
   entry1->Close();
   ASSERT_TRUE(cache_->OpenEntry(key, &entry1));
   EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer1, kSize, NULL));
 
   SimulateCrash();
 
   EXPECT_FALSE(cache_->OpenEntry(key, &entry1));
   EXPECT_EQ(0, cache_->GetEntryCount());
@@ skipping 145 matching lines @@
   // Use the implementation directly... we need to simulate a crash.
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry *entry, *entry1, *entry2;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+  memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
   entry1->Close();
   ASSERT_TRUE(cache_->OpenEntry(key, &entry1));
   EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer1, kSize, NULL));
 
   std::string key2("Another key");
   ASSERT_TRUE(cache_->CreateEntry(key2, &entry2));
   entry2->Close();
   ASSERT_EQ(2, cache_->GetEntryCount());
@@ skipping 407 matching lines @@
   InitCache();
   BackendDoomAll();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
   SetMemoryOnlyMode();
   InitCache();
   BackendDoomAll();
 }