Extend the IOBuffer to the disk cache....

net/disk_cache/backend_unittest.cc

Index: net/disk_cache/backend_unittest.cc
===================================================================
--- net/disk_cache/backend_unittest.cc	(revision 9532)
+++ net/disk_cache/backend_unittest.cc	(working copy)
@@ -7,6 +7,7 @@
 #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"
@@ -209,21 +210,21 @@
   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() {
@@ -237,7 +238,8 @@
   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";
 
@@ -338,20 +340,20 @@
   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
@@ -366,9 +368,10 @@
   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));
@@ -386,12 +389,13 @@
   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();
 
@@ -462,7 +466,8 @@
   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));
 
@@ -549,12 +554,13 @@
   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));