Extend the IOBuffer to the disk cache.

net/disk_cache/disk_cache_perftest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/perftimer.h"
 #include "base/string_util.h"
 #include "base/test_file_util.h"
 #include "base/timer.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/hash.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
@@ skipping 10 matching lines @@
   int data_len;
 };
 typedef std::vector<TestEntry> TestEntries;
 
 const int kMaxSize = 16 * 1024 - 1;
 
 // Creates num_entries on the cache, and writes 200 bytes of metadata and up
 // to kMaxSize of data to each entry.
 int TimeWrite(int num_entries, disk_cache::Backend* cache,
               TestEntries* entries) {
-  char buffer1[200];
-  char buffer2[kMaxSize];
+  const int kSize1 = 200;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
+  scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kMaxSize);
 
-  CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
-  CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
+  CacheTestFillBuffer(buffer1->data(), kSize1, false);
+  CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
 
   CallbackTest callback(1);
   g_cache_tests_error = false;
   g_cache_tests_max_id = 1;
   g_cache_tests_received = 0;
   int expected = 0;
 
   MessageLoopHelper helper;
 
   PerfTimeLogger timer("Write disk cache entries");
 
   for (int i = 0; i < num_entries; i++) {
     TestEntry entry;
     entry.key = GenerateKey(true);
-    entry.data_len = rand() % sizeof(buffer2);
+    entry.data_len = rand() % kMaxSize;
     entries->push_back(entry);
 
     disk_cache::Entry* cache_entry;
     if (!cache->CreateEntry(entry.key, &cache_entry))
       break;
-    int ret = cache_entry->WriteData(0, 0, buffer1, sizeof(buffer1), &callback,
-                                     false);
+    int ret = cache_entry->WriteData(0, 0, buffer1, kSize1, &callback, false);
     if (net::ERR_IO_PENDING == ret)
       expected++;
-    else if (sizeof(buffer1) != ret)
+    else if (kSize1 != ret)
       break;
 
     ret = cache_entry->WriteData(1, 0, buffer2, entry.data_len, &callback,
                                  false);
     if (net::ERR_IO_PENDING == ret)
       expected++;
     else if (entry.data_len != ret)
       break;
     cache_entry->Close();
   }
 
   helper.WaitUntilCacheIoFinished(expected);
   timer.Done();
 
   return expected;
 }
 
 // Reads the data and metadata from each entry listed on |entries|.
 int TimeRead(int num_entries, disk_cache::Backend* cache,
              const TestEntries& entries, bool cold) {
-  char buffer1[200];
-  char buffer2[kMaxSize];
+  const int kSize1 = 200;
+  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
+  scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kMaxSize);
 
-  CacheTestFillBuffer(buffer1, sizeof(buffer1), false);
-  CacheTestFillBuffer(buffer2, sizeof(buffer2), false);
+  CacheTestFillBuffer(buffer1->data(), kSize1, false);
+  CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
 
   CallbackTest callback(1);
   g_cache_tests_error = false;
   g_cache_tests_max_id = 1;
   g_cache_tests_received = 0;
   int expected = 0;
 
   MessageLoopHelper helper;
 
   const char* message = cold ? "Read disk cache entries (cold)" :
                         "Read disk cache entries (warm)";
   PerfTimeLogger timer(message);
 
   for (int i = 0; i < num_entries; i++) {
     disk_cache::Entry* cache_entry;
     if (!cache->OpenEntry(entries[i].key, &cache_entry))
       break;
-    int ret = cache_entry->ReadData(0, 0, buffer1, sizeof(buffer1), &callback);
+    int ret = cache_entry->ReadData(0, 0, buffer1, kSize1, &callback);
     if (net::ERR_IO_PENDING == ret)
       expected++;
-    else if (sizeof(buffer1) != ret)
+    else if (kSize1 != ret)
       break;
 
     ret = cache_entry->ReadData(1, 0, buffer2, entries[i].data_len, &callback);
     if (net::ERR_IO_PENDING == ret)
       expected++;
     else if (entries[i].data_len != ret)
       break;
     cache_entry->Close();
   }
 
@@ skipping 108 matching lines @@
       entry = 0;
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
   MessageLoop::current()->RunAllPending();
 }