summaryrefslogtreecommitdiffstats
path: root/net/disk_cache
diff options
context:
space:
mode:
Diffstat (limited to 'net/disk_cache')
-rw-r--r--net/disk_cache/backend_impl.cc8
-rw-r--r--net/disk_cache/backend_unittest.cc28
-rw-r--r--net/disk_cache/disk_cache_perftest.cc8
-rw-r--r--net/disk_cache/entry_unittest.cc100
-rw-r--r--net/disk_cache/file_posix.cc8
-rw-r--r--net/disk_cache/in_flight_backend_io.cc42
-rw-r--r--net/disk_cache/mem_entry_impl.cc8
-rw-r--r--net/disk_cache/sparse_control.cc24
-rw-r--r--net/disk_cache/stats_histogram.cc2
-rw-r--r--net/disk_cache/stress_cache.cc2
10 files changed, 115 insertions, 115 deletions
diff --git a/net/disk_cache/backend_impl.cc b/net/disk_cache/backend_impl.cc
index 4765a44..2b17e48 100644
--- a/net/disk_cache/backend_impl.cc
+++ b/net/disk_cache/backend_impl.cc
@@ -174,13 +174,13 @@ bool SetFieldTrialInfo(int size_group) {
// Field trials involve static objects so we have to do this only once.
first = false;
- scoped_refptr<base::FieldTrial> trial1 =
- new base::FieldTrial("CacheSize", 10);
+ scoped_refptr<base::FieldTrial> trial1(
+ new base::FieldTrial("CacheSize", 10));
std::string group1 = base::StringPrintf("CacheSizeGroup_%d", size_group);
trial1->AppendGroup(group1, base::FieldTrial::kAllRemainingProbability);
- scoped_refptr<base::FieldTrial> trial2 =
- new base::FieldTrial("CacheThrottle", 100);
+ scoped_refptr<base::FieldTrial> trial2(
+ new base::FieldTrial("CacheThrottle", 100));
int group2a = trial2->AppendGroup("CacheThrottle_On", 10); // 10 % in.
trial2->AppendGroup("CacheThrottle_Off", 10); // 10 % control.
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index adfc95c..4298456 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -230,7 +230,7 @@ TEST_F(DiskCacheBackendTest, ExternalFiles) {
FilePath filename = GetCacheFilePath().AppendASCII("f_000001");
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer1->data(), kSize, false);
ASSERT_EQ(kSize, file_util::WriteFile(filename, buffer1->data(), kSize));
@@ -241,7 +241,7 @@ TEST_F(DiskCacheBackendTest, ExternalFiles) {
entry->Close();
// And verify that the first file is still there.
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+ 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));
}
@@ -269,7 +269,7 @@ TEST_F(DiskCacheTest, ShutdownWithPendingIO) {
ASSERT_EQ(net::OK, cb.GetResult(rv));
const int kSize = 25000;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
@@ -319,7 +319,7 @@ TEST_F(DiskCacheTest, ShutdownWithPendingIO2) {
ASSERT_EQ(net::OK, cb.GetResult(rv));
const int kSize = 25000;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
rv = entry->WriteData(0, 0, buffer, kSize, &cb, false);
@@ -366,7 +366,7 @@ void DiskCacheBackendTest::BackendSetSize() {
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(first, &entry));
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(cache_size);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
memset(buffer->data(), 0, cache_size);
EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
false)) << "normal file";
@@ -497,7 +497,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+ 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, WriteData(entry, 0, 0, buffer1, kSize, false));
@@ -506,7 +506,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
memset(buffer2->data(), 0, kSize);
EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2, kSize));
entry->Close();
@@ -535,7 +535,7 @@ void DiskCacheBackendTest::BackendInvalidEntry() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 0, kSize);
base::strlcpy(buffer->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
@@ -579,7 +579,7 @@ void DiskCacheBackendTest::BackendInvalidEntryRead() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 0, kSize);
base::strlcpy(buffer->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
@@ -697,7 +697,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry() {
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(first, &entry));
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 0, kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
@@ -748,7 +748,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
SetMaxSize(kSize * 40);
InitCache();
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 0, kSize);
disk_cache::Entry* entry;
@@ -940,7 +940,7 @@ void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
+ 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, WriteData(entry1, 0, 0, buffer1, kSize, false));
@@ -1574,7 +1574,7 @@ void DiskCacheBackendTest::BackendDisable4() {
ASSERT_EQ(net::OK, CreateEntry(key3, &entry3));
const int kBufSize = 20000;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kBufSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
memset(buf->data(), 0, kBufSize);
EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
@@ -1840,7 +1840,7 @@ TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 200;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, true);
for (int i = 0; i < 10; i++) {
diff --git a/net/disk_cache/disk_cache_perftest.cc b/net/disk_cache/disk_cache_perftest.cc
index 1f1514d..c86955f 100644
--- a/net/disk_cache/disk_cache_perftest.cc
+++ b/net/disk_cache/disk_cache_perftest.cc
@@ -44,8 +44,8 @@ const int kMaxSize = 16 * 1024 - 1;
int TimeWrite(int num_entries, disk_cache::Backend* cache,
TestEntries* entries) {
const int kSize1 = 200;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kMaxSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kMaxSize));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
@@ -95,8 +95,8 @@ int TimeWrite(int num_entries, disk_cache::Backend* cache,
int TimeRead(int num_entries, disk_cache::Backend* cache,
const TestEntries& entries, bool cold) {
const int kSize1 = 200;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kMaxSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kMaxSize));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index c4dc705f..41f9077 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -76,7 +76,7 @@ class InternalSyncIOTask : public SyncIOTask {
// This part of the test runs on the background thread.
void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
const int kSize1 = 10;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
EXPECT_EQ(0, entry->ReadData(0, 0, buffer1, kSize1, NULL));
base::strlcpy(buffer1->data(), "the data", kSize1);
@@ -87,8 +87,8 @@ void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
const int kSize2 = 5000;
const int kSize3 = 10000;
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
- scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3);
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
+ scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
memset(buffer3->data(), 0, kSize3);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
@@ -179,9 +179,9 @@ void DiskCacheEntryTest::InternalAsyncIO() {
const int kSize1 = 10;
const int kSize2 = 5000;
const int kSize3 = 10000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
- scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
+ scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
CacheTestFillBuffer(buffer3->data(), kSize3, false);
@@ -298,8 +298,8 @@ class ExternalSyncIOTask : public SyncIOTask {
void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
const int kSize1 = 17000;
const int kSize2 = 25000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
base::strlcpy(buffer1->data(), "the data", kSize1);
@@ -383,9 +383,9 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
const int kSize1 = 17000;
const int kSize2 = 25000;
const int kSize3 = 25000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
- scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
+ scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
CacheTestFillBuffer(buffer3->data(), kSize3, false);
@@ -481,8 +481,8 @@ void DiskCacheEntryTest::StreamAccess() {
ASSERT_TRUE(NULL != entry);
const int kBufferSize = 1024;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kBufferSize);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kBufferSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kBufferSize));
const int kNumStreams = 3;
for (int i = 0; i < kNumStreams; i++) {
@@ -579,7 +579,7 @@ void DiskCacheEntryTest::GetTimes() {
Time t3 = Time::Now();
EXPECT_TRUE(t3 > t2);
const int kSize = 200;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
if (type_ == net::APP_CACHE) {
EXPECT_TRUE(entry->GetLastUsed() < t2);
@@ -614,8 +614,8 @@ void DiskCacheEntryTest::GrowData() {
ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
const int kSize = 20000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer1->data(), kSize, false);
memset(buffer2->data(), 0, kSize);
@@ -699,8 +699,8 @@ void DiskCacheEntryTest::TruncateData() {
const int kSize1 = 20000;
const int kSize2 = 20000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
memset(buffer2->data(), 0, kSize2);
@@ -801,7 +801,7 @@ void DiskCacheEntryTest::ZeroLengthIO() {
// Lets verify the actual content.
const int kSize = 20;
const char zeros[kSize] = {};
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer, kSize));
@@ -843,8 +843,8 @@ void DiskCacheEntryTest::Buffering() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 200;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer1->data(), kSize, true);
CacheTestFillBuffer(buffer2->data(), kSize, true);
@@ -924,8 +924,8 @@ void DiskCacheEntryTest::SizeChanges() {
const int kSize = 200;
const char zeros[kSize] = {};
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer1->data(), kSize, true);
CacheTestFillBuffer(buffer2->data(), kSize, true);
@@ -1013,7 +1013,7 @@ void DiskCacheEntryTest::ReuseEntry(int size) {
std::string key2("the second key");
ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
CacheTestFillBuffer(buffer->data(), size, false);
for (int i = 0; i < 15; i++) {
@@ -1067,9 +1067,9 @@ void DiskCacheEntryTest::InvalidData() {
const int kSize1 = 20000;
const int kSize2 = 20000;
const int kSize3 = 20000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
- scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
+ scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
memset(buffer2->data(), 0, kSize2);
@@ -1149,7 +1149,7 @@ TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 200;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
TestCompletionCallback cb;
@@ -1179,7 +1179,7 @@ void DiskCacheEntryTest::DoomNormalEntry() {
entry->Close();
const int kSize = 20000;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, true);
buffer->data()[19999] = '\0';
@@ -1220,8 +1220,8 @@ void DiskCacheEntryTest::DoomedEntry() {
const int kSize1 = 2000;
const int kSize2 = 2000;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
- scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
+ scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+ scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
memset(buffer2->data(), 0, kSize2);
@@ -1254,7 +1254,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
InitCache();
const int kSize = 4096;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
std::string key("the first key");
@@ -1308,7 +1308,7 @@ void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
int size) {
TestCompletionCallback cb;
- scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(size);
+ scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
memset(buf_1->data(), 0, size);
int ret = entry->ReadSparseData(offset, buf_1, size, &cb);
EXPECT_EQ(size, cb.GetResult(ret));
@@ -1322,8 +1322,8 @@ void DiskCacheEntryTest::BasicSparseIO() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 2048;
- scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf_1->data(), kSize, false);
// Write at offset 0.
@@ -1363,8 +1363,8 @@ void DiskCacheEntryTest::HugeSparseIO() {
// Write 1.2 MB so that we cover multiple entries.
const int kSize = 1200 * 1024;
- scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf_1->data(), kSize, false);
// Write at offset 0x20F0000 (33 MB - 64 KB).
@@ -1394,7 +1394,7 @@ void DiskCacheEntryTest::GetAvailableRange() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 16 * 1024;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
// Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
@@ -1456,7 +1456,7 @@ void DiskCacheEntryTest::CouldBeSparse() {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 16 * 1024;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
// Write at offset 0x20F0000 (33 MB - 64 KB).
@@ -1502,8 +1502,8 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
InitCache();
const int kSize = 8192;
- scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize);
- scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
+ scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf_1->data(), kSize, false);
std::string key("the first key");
@@ -1512,8 +1512,8 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
// This loop writes back to back starting from offset 0 and 9000.
for (int i = 0; i < kSize; i += 1024) {
- scoped_refptr<net::WrappedIOBuffer> buf_3 =
- new net::WrappedIOBuffer(buf_1->data() + i);
+ scoped_refptr<net::WrappedIOBuffer> buf_3(
+ new net::WrappedIOBuffer(buf_1->data() + i));
VerifySparseIO(entry, i, buf_3, 1024, buf_2);
VerifySparseIO(entry, 9000 + i, buf_3, 1024, buf_2);
}
@@ -1533,7 +1533,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
InitCache();
const int kSize = 8192;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
disk_cache::Entry* entry;
@@ -1594,7 +1594,7 @@ void DiskCacheEntryTest::DoomSparseEntry() {
ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
const int kSize = 4 * 1024;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
int64 offset = 1024;
@@ -1681,7 +1681,7 @@ TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 4 * 1024;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
int64 offset = 1024;
@@ -1711,7 +1711,7 @@ void DiskCacheEntryTest::PartialSparseEntry() {
// of a sparse entry, at least to write a big range without leaving holes.
const int kSize = 4 * 1024;
const int kSmallSize = 128;
- scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf1->data(), kSize, false);
// The first write is just to extend the entry. The third write occupies
@@ -1723,7 +1723,7 @@ void DiskCacheEntryTest::PartialSparseEntry() {
entry->Close();
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- scoped_refptr<net::IOBuffer> buf2 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
memset(buf2->data(), 0, kSize);
EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2, kSize));
@@ -1805,7 +1805,7 @@ TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 4 * 1024;
- scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf1->data(), kSize, false);
const int k1Meg = 1024 * 1024;
@@ -1856,7 +1856,7 @@ TEST_F(DiskCacheEntryTest, CancelSparseIO) {
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 40 * 1024;
- scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
CacheTestFillBuffer(buf->data(), kSize, false);
// This will open and write two "real" entries.
diff --git a/net/disk_cache/file_posix.cc b/net/disk_cache/file_posix.cc
index 9d810c7..bade848 100644
--- a/net/disk_cache/file_posix.cc
+++ b/net/disk_cache/file_posix.cc
@@ -182,8 +182,8 @@ void BackgroundIO::OnIOSignalled() {
void InFlightIO::PostRead(disk_cache::File *file, void* buf, size_t buf_len,
size_t offset, disk_cache::FileIOCallback *callback) {
- scoped_refptr<BackgroundIO> operation =
- new BackgroundIO(file, buf, buf_len, offset, callback, this);
+ scoped_refptr<BackgroundIO> operation(
+ new BackgroundIO(file, buf, buf_len, offset, callback, this));
io_list_.insert(operation.get());
file->AddRef(); // Balanced on InvokeCallback()
@@ -198,8 +198,8 @@ void InFlightIO::PostRead(disk_cache::File *file, void* buf, size_t buf_len,
void InFlightIO::PostWrite(disk_cache::File* file, const void* buf,
size_t buf_len, size_t offset,
disk_cache::FileIOCallback* callback) {
- scoped_refptr<BackgroundIO> operation =
- new BackgroundIO(file, buf, buf_len, offset, callback, this);
+ scoped_refptr<BackgroundIO> operation(
+ new BackgroundIO(file, buf, buf_len, offset, callback, this));
io_list_.insert(operation.get());
file->AddRef(); // Balanced on InvokeCallback()
diff --git a/net/disk_cache/in_flight_backend_io.cc b/net/disk_cache/in_flight_backend_io.cc
index fe53829..8fafa4d 100644
--- a/net/disk_cache/in_flight_backend_io.cc
+++ b/net/disk_cache/in_flight_backend_io.cc
@@ -291,34 +291,34 @@ InFlightBackendIO::~InFlightBackendIO() {
}
void InFlightBackendIO::Init(CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->Init();
QueueOperation(operation);
}
void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->OpenEntry(key, entry);
QueueOperation(operation);
}
void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->CreateEntry(key, entry);
QueueOperation(operation);
}
void InFlightBackendIO::DoomEntry(const std::string& key,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->DoomEntry(key);
QueueOperation(operation);
}
void InFlightBackendIO::DoomAllEntries(CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->DoomAllEntries();
QueueOperation(operation);
}
@@ -326,58 +326,58 @@ void InFlightBackendIO::DoomAllEntries(CompletionCallback* callback) {
void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
const base::Time end_time,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->DoomEntriesBetween(initial_time, end_time);
QueueOperation(operation);
}
void InFlightBackendIO::DoomEntriesSince(const base::Time initial_time,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->DoomEntriesSince(initial_time);
QueueOperation(operation);
}
void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->OpenNextEntry(iter, next_entry);
QueueOperation(operation);
}
void InFlightBackendIO::OpenPrevEntry(void** iter, Entry** prev_entry,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->OpenPrevEntry(iter, prev_entry);
QueueOperation(operation);
}
void InFlightBackendIO::EndEnumeration(void* iterator) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, NULL);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, NULL));
operation->EndEnumeration(iterator);
QueueOperation(operation);
}
void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, NULL);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, NULL));
operation->CloseEntryImpl(entry);
QueueOperation(operation);
}
void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, NULL);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, NULL));
operation->DoomEntryImpl(entry);
QueueOperation(operation);
}
void InFlightBackendIO::FlushQueue(net::CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->FlushQueue();
QueueOperation(operation);
}
void InFlightBackendIO::RunTask(Task* task, net::CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->RunTask(task);
QueueOperation(operation);
}
@@ -385,7 +385,7 @@ void InFlightBackendIO::RunTask(Task* task, net::CompletionCallback* callback) {
void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
net::IOBuffer* buf, int buf_len,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->ReadData(entry, index, offset, buf, buf_len);
QueueOperation(operation);
}
@@ -394,7 +394,7 @@ void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
net::IOBuffer* buf, int buf_len,
bool truncate,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->WriteData(entry, index, offset, buf, buf_len, truncate);
QueueOperation(operation);
}
@@ -402,7 +402,7 @@ void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
void InFlightBackendIO::ReadSparseData(EntryImpl* entry, int64 offset,
net::IOBuffer* buf, int buf_len,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->ReadSparseData(entry, offset, buf, buf_len);
QueueOperation(operation);
}
@@ -410,7 +410,7 @@ void InFlightBackendIO::ReadSparseData(EntryImpl* entry, int64 offset,
void InFlightBackendIO::WriteSparseData(EntryImpl* entry, int64 offset,
net::IOBuffer* buf, int buf_len,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->WriteSparseData(entry, offset, buf, buf_len);
QueueOperation(operation);
}
@@ -418,20 +418,20 @@ void InFlightBackendIO::WriteSparseData(EntryImpl* entry, int64 offset,
void InFlightBackendIO::GetAvailableRange(EntryImpl* entry, int64 offset,
int len, int64* start,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->GetAvailableRange(entry, offset, len, start);
QueueOperation(operation);
}
void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, NULL);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, NULL));
operation->CancelSparseIO(entry);
QueueOperation(operation);
}
void InFlightBackendIO::ReadyForSparseIO(EntryImpl* entry,
CompletionCallback* callback) {
- scoped_refptr<BackendIO> operation = new BackendIO(this, backend_, callback);
+ scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
operation->ReadyForSparseIO(entry);
QueueOperation(operation);
}
diff --git a/net/disk_cache/mem_entry_impl.cc b/net/disk_cache/mem_entry_impl.cc
index 8d8bb4c..a9e599c 100644
--- a/net/disk_cache/mem_entry_impl.cc
+++ b/net/disk_cache/mem_entry_impl.cc
@@ -172,8 +172,8 @@ int MemEntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
return net::ERR_INVALID_ARGUMENT;
// We will keep using this buffer and adjust the offset in this buffer.
- scoped_refptr<net::DrainableIOBuffer> io_buf =
- new net::DrainableIOBuffer(buf, buf_len);
+ scoped_refptr<net::DrainableIOBuffer> io_buf(
+ new net::DrainableIOBuffer(buf, buf_len));
// Iterate until we have read enough.
while (io_buf->BytesRemaining()) {
@@ -218,8 +218,8 @@ int MemEntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
if (offset < 0 || buf_len < 0)
return net::ERR_INVALID_ARGUMENT;
- scoped_refptr<net::DrainableIOBuffer> io_buf =
- new net::DrainableIOBuffer(buf, buf_len);
+ scoped_refptr<net::DrainableIOBuffer> io_buf(
+ new net::DrainableIOBuffer(buf, buf_len));
// This loop walks through child entries continuously starting from |offset|
// and writes blocks of data (of maximum size kMaxSparseEntrySize) into each
diff --git a/net/disk_cache/sparse_control.cc b/net/disk_cache/sparse_control.cc
index e94a1bc..32f44ab 100644
--- a/net/disk_cache/sparse_control.cc
+++ b/net/disk_cache/sparse_control.cc
@@ -319,8 +319,8 @@ int SparseControl::CreateSparseEntry() {
children_map_.Resize(kNumSparseBits, true);
// Save the header. The bitmap is saved in the destructor.
- scoped_refptr<net::IOBuffer> buf =
- new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_));
+ scoped_refptr<net::IOBuffer> buf(
+ new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
int rv = entry_->WriteData(kSparseIndex, 0, buf, sizeof(sparse_header_), NULL,
false);
@@ -349,8 +349,8 @@ int SparseControl::OpenSparseEntry(int data_len) {
if (map_len > kMaxMapSize || map_len % 4)
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
- scoped_refptr<net::IOBuffer> buf =
- new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_));
+ scoped_refptr<net::IOBuffer> buf(
+ new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
// Read header.
int rv = entry_->ReadData(kSparseIndex, 0, buf, sizeof(sparse_header_), NULL);
@@ -402,8 +402,8 @@ bool SparseControl::OpenChild() {
static_cast<int>(sizeof(child_data_)))
return KillChildAndContinue(key, false);
- scoped_refptr<net::WrappedIOBuffer> buf =
- new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
+ scoped_refptr<net::WrappedIOBuffer> buf(
+ new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
// Read signature.
int rv = child_->ReadData(kSparseIndex, 0, buf, sizeof(child_data_), NULL);
@@ -425,8 +425,8 @@ bool SparseControl::OpenChild() {
}
void SparseControl::CloseChild() {
- scoped_refptr<net::WrappedIOBuffer> buf =
- new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
+ scoped_refptr<net::WrappedIOBuffer> buf(
+ new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
// Save the allocation bitmap before closing the child entry.
int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
@@ -492,8 +492,8 @@ void SparseControl::SetChildBit(bool value) {
}
void SparseControl::WriteSparseData() {
- scoped_refptr<net::IOBuffer> buf = new net::WrappedIOBuffer(
- reinterpret_cast<const char*>(children_map_.GetMap()));
+ scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer(
+ reinterpret_cast<const char*>(children_map_.GetMap())));
int len = children_map_.ArraySize() * 4;
int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf, len,
@@ -597,8 +597,8 @@ void SparseControl::InitChildData() {
memset(&child_data_, 0, sizeof(child_data_));
child_data_.header = sparse_header_;
- scoped_refptr<net::WrappedIOBuffer> buf =
- new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
+ scoped_refptr<net::WrappedIOBuffer> buf(
+ new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
NULL, false);
diff --git a/net/disk_cache/stats_histogram.cc b/net/disk_cache/stats_histogram.cc
index 06ed1b3..bc3f5d3 100644
--- a/net/disk_cache/stats_histogram.cc
+++ b/net/disk_cache/stats_histogram.cc
@@ -42,7 +42,7 @@ scoped_refptr<StatsHistogram> StatsHistogram::StatsHistogramFactoryGet(
Histogram* temp_histogram = histogram.get();
StatsHistogram* temp_stats_histogram =
static_cast<StatsHistogram*>(temp_histogram);
- scoped_refptr<StatsHistogram> return_histogram = temp_stats_histogram;
+ scoped_refptr<StatsHistogram> return_histogram(temp_stats_histogram);
return return_histogram;
}
diff --git a/net/disk_cache/stress_cache.cc b/net/disk_cache/stress_cache.cc
index dcde1e1..ae2f981 100644
--- a/net/disk_cache/stress_cache.cc
+++ b/net/disk_cache/stress_cache.cc
@@ -130,7 +130,7 @@ void StressTheCache(int iteration) {
}
const int kSize = 4000;
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 'k', kSize);
for (int i = 0;; i++) {
generated by cgit v1.1 at 2025-02-07 02:00:03 +0000