Extend the IOBuffer to the disk cache.

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"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/mapped_file.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
@@ skipping 182 matching lines @@
   InitCache();
   BackendKeying();
 }
 
 TEST_F(DiskCacheBackendTest, ExternalFiles) {
   InitCache();
   // First, lets create a file on the folder.
   std::wstring filename = GetCachePath();
   file_util::AppendToPath(&filename, L"f_000001");
 
-  const int kDataSize = 50;
-  char data[kDataSize];
-  CacheTestFillBuffer(data, kDataSize, false);
-  ASSERT_EQ(kDataSize, file_util::WriteFile(filename, data, kDataSize));
+  const int kSize = 50;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+  CacheTestFillBuffer(buffer1->data(), kSize, false);
+  ASSERT_EQ(kSize, file_util::WriteFile(filename, buffer1->data(), kSize));
 
   // Now let's create a file with the cache.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache_->CreateEntry("key", &entry));
-  ASSERT_EQ(0, entry->WriteData(0, 20000, data, 0, NULL, false));
+  ASSERT_EQ(0, entry->WriteData(0, 20000, buffer1, 0, NULL, false));
   entry->Close();
 
   // And verify that the first file is still there.
-  char buffer[kDataSize];
-  ASSERT_EQ(kDataSize, file_util::ReadFile(filename, buffer, kDataSize));
-  EXPECT_EQ(0, memcmp(data, buffer, kDataSize));
+  scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+  ASSERT_EQ(kSize, file_util::ReadFile(filename, buffer2->data(), kSize));
+  EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
 }
 
 void DiskCacheBackendTest::BackendSetSize() {
   SetDirectMode();
   const int cache_size = 0x10000;  // 64 kB
   SetMaxSize(cache_size);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache_->CreateEntry(first, &entry));
 
-  char buffer[cache_size] = {0};
+  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(cache_size);
+  memset(buffer->data(), 0, cache_size);
   EXPECT_EQ(cache_size / 10, entry->WriteData(0, 0, buffer, cache_size / 10,
                                               NULL, false)) << "normal file";
 
   EXPECT_EQ(net::ERR_FAILED, entry->WriteData(1, 0, buffer, cache_size / 5,
                 NULL, false)) << "file size above the limit";
 
   // By doubling the total size, we make this file cacheable.
   SetMaxSize(cache_size * 2);
   EXPECT_EQ(cache_size / 5, entry->WriteData(1, 0, buffer, cache_size / 5,
                                              NULL, false));
@@ skipping 80 matching lines @@
 
 // Before looking for invalid entries, let's check a valid entry.
 TEST_F(DiskCacheBackendTest, ValidEntry) {
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry1;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
 
-  char data[] = "And the data to save";
-  EXPECT_TRUE(sizeof(data) == entry1->WriteData(0, 0, data, sizeof(data), NULL,
-                                                false));
+  const int kSize = 50;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(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));
 
-  char buffer[40];
-  memset(buffer, 0, sizeof(buffer));
-  EXPECT_TRUE(sizeof(data) == entry1->ReadData(0, 0, buffer, sizeof(data),
-                                               NULL));
+  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(data, buffer);
+  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));
 
-  char data[] = "And the data to save";
-  EXPECT_TRUE(sizeof(data) == entry1->WriteData(0, 0, data, sizeof(data), NULL,
-                                                false));
+  const int kSize = 50;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(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));
 
-  char data[] = "And the data to save";
-  EXPECT_TRUE(sizeof(data) == entry1->WriteData(0, 0, data, sizeof(data), NULL,
-                                                false));
+  const int kSize = 50;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(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_TRUE(sizeof(data) == entry1->ReadData(0, 0, data, sizeof(data), NULL));
+  EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer1, kSize, NULL));
 
   SimulateCrash();
 
   EXPECT_FALSE(cache_->OpenEntry(key, &entry1));
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntryWithLoad) {
   // Work with a tiny index table (16 entries)
@@ skipping 50 matching lines @@
 
   const int cache_size = 0x4000;  // 16 kB
   SetMaxSize(cache_size * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache_->CreateEntry(first, &entry));
 
-  char buffer[cache_size] = {0};
+  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(cache_size);
+  memset(buffer->data(), 0, cache_size);
   EXPECT_EQ(cache_size * 19 / 20, entry->WriteData(0, 0, buffer,
                 cache_size * 19 / 20, NULL, false));
 
   // Simulate a crash.
   SimulateCrash();
 
   ASSERT_TRUE(cache_->CreateEntry(second, &entry));
   EXPECT_EQ(cache_size / 10, entry->WriteData(0, 0, buffer, cache_size / 10,
                                               NULL, false)) << "trim the cache";
   entry->Close();
@@ skipping 66 matching lines @@
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntryEnumeration) {
   // 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));
 
-  char data[] = "And the data to save";
-  EXPECT_TRUE(sizeof(data) == entry1->WriteData(0, 0, data, sizeof(data), NULL,
-                                                false));
+  const int kSize = 50;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(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_TRUE(sizeof(data) == entry1->ReadData(0, 0, data, sizeof(data), NULL));
+  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());
 
   SimulateCrash();
 
   void* iter = NULL;
   int count = 0;
@@ skipping 402 matching lines @@
   InitCache();
   BackendDoomAll();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
   SetMemoryOnlyMode();
   InitCache();
   BackendDoomAll();
 }