net/disk_cache/backend_unittest.cc - Issue 11275088: Remove implicit scoped_refptr operator T*

Unified Diff: net/disk_cache/backend_unittest.cc

Issue 11275088: Remove implicit scoped_refptr operator T* Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 8 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/disk_cache/backend_unittest.cc

diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc

index b6fa92086a9b89a2f36db78fba93aefce6720667..629409a28780bc81cb74d91e18e0fec55e9b5f58 100644

--- a/net/disk_cache/backend_unittest.cc

+++ b/net/disk_cache/backend_unittest.cc

@@ -211,7 +211,7 @@ TEST_F(DiskCacheTest, CreateBackend) {

disk_cache::Backend* cache = NULL;

int rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, false, 0, net::DISK_CACHE, disk_cache::kNoRandom,

- cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache, cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

ASSERT_TRUE(cache);

delete cache;

@@ -223,7 +223,7 @@ TEST_F(DiskCacheTest, CreateBackend) {

// Now test the public API.

rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, cache_path_, 0, false,

- cache_thread.message_loop_proxy(),

+ cache_thread.message_loop_proxy().get(),

NULL, &cache, cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

ASSERT_TRUE(cache);

@@ -266,7 +266,7 @@ TEST_F(DiskCacheBackendTest, ExternalFiles) {

// Now let's create a file with the cache.

disk_cache::Entry* entry;

ASSERT_EQ(net::OK, CreateEntry("key", &entry));

- ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1, 0, false));

+ ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));

entry->Close();

// And verify that the first file is still there.

@@ -292,8 +292,8 @@ void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {

flags |= disk_cache::kNoRandom;

rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, false, 0, net::DISK_CACHE, flags,

- base::MessageLoopProxy::current(), NULL,

- &cache, cb.callback());

+ base::MessageLoopProxy::current().get(), NULL,

+ &cache, cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

disk_cache::EntryImpl* entry;

@@ -310,7 +310,8 @@ void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {

// We are using the current thread as the cache thread because we want to

// be able to call directly this method to make sure that the OS (instead

// of us switching thread) is returning IO pending.

- rv = entry->WriteDataImpl(0, i, buffer, kSize, cb.callback(), false);

+ rv = entry->

+ WriteDataImpl(0, i, buffer.get(), kSize, cb.callback(), false);

if (rv == net::ERR_IO_PENDING)

break;

EXPECT_EQ(kSize, rv);

@@ -370,7 +371,7 @@ void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {

flags |= disk_cache::kNoRandom;

int rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, false, 0, net::DISK_CACHE, flags,

- cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache, cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

disk_cache::Entry* entry;

@@ -413,7 +414,7 @@ void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {

fast ? disk_cache::kNone : disk_cache::kNoRandom;

int rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, false, 0, net::DISK_CACHE, flags,

- cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache, cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

disk_cache::Entry* entry;

@@ -452,7 +453,7 @@ TEST_F(DiskCacheTest, TruncatedIndex) {

disk_cache::Backend* backend = NULL;

int rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, false, 0, net::DISK_CACHE, disk_cache::kNone,

- cache_thread.message_loop_proxy(), NULL, &backend, cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &backend, cb.callback());

ASSERT_NE(net::OK, cb.GetResult(rv));

ASSERT_TRUE(backend == NULL);

@@ -472,20 +473,22 @@ void DiskCacheBackendTest::BackendSetSize() {

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";

+ EXPECT_EQ(

+ cache_size / 10, WriteData(entry, 0, 0, buffer.get(), cache_size / 10,

+ false)) << "normal file";

- EXPECT_EQ(net::ERR_FAILED, WriteData(entry, 1, 0, buffer, cache_size / 5,

- false)) << "file size above the limit";

+ EXPECT_EQ(

+ net::ERR_FAILED, WriteData(entry, 1, 0, buffer.get(), cache_size / 5,

+ 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, WriteData(entry, 1, 0, buffer, cache_size / 5,

+ EXPECT_EQ(cache_size / 5, WriteData(entry, 1, 0, buffer.get(), cache_size / 5,

false));

// Let's fill up the cache!.

SetMaxSize(cache_size * 10);

- EXPECT_EQ(cache_size * 3 / 4, WriteData(entry, 0, 0, buffer,

+ EXPECT_EQ(cache_size * 3 / 4, WriteData(entry, 0, 0, buffer.get(),

cache_size * 3 / 4, false));

entry->Close();

FlushQueueForTest();

@@ -495,13 +498,15 @@ void DiskCacheBackendTest::BackendSetSize() {

// The cache is 95% full.

ASSERT_EQ(net::OK, CreateEntry(second, &entry));

- EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,

- false));

+ EXPECT_EQ(

+ cache_size / 10, WriteData(entry, 0, 0, buffer.get(), cache_size / 10,

+ false));

disk_cache::Entry* entry2;

ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));

- EXPECT_EQ(cache_size / 10, WriteData(entry2, 0, 0, buffer, cache_size / 10,

- false));

+ EXPECT_EQ(

+ cache_size / 10, WriteData(entry2, 0, 0, buffer.get(), cache_size / 10,

+ false));

entry2->Close(); // This will trigger the cache trim.

EXPECT_NE(net::OK, OpenEntry(first, &entry2));

@@ -662,7 +667,7 @@ void DiskCacheBackendTest::BackendValidEntry() {

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));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));

entry->Close();

SimulateCrash();

@@ -670,7 +675,7 @@ void DiskCacheBackendTest::BackendValidEntry() {

scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));

memset(buffer2->data(), 0, kSize);

- EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2, kSize));

+ EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));

entry->Close();

EXPECT_STREQ(buffer1->data(), buffer2->data());

}

@@ -700,7 +705,7 @@ void DiskCacheBackendTest::BackendInvalidEntry() {

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));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

SimulateCrash();

EXPECT_NE(net::OK, OpenEntry(key, &entry));

@@ -743,10 +748,10 @@ void DiskCacheBackendTest::BackendInvalidEntryRead() {

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));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

entry->Close();

ASSERT_EQ(net::OK, OpenEntry(key, &entry));

- EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));

+ EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));

SimulateCrash();

@@ -860,13 +865,13 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry() {

scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));

memset(buffer->data(), 0, kSize);

- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

// Simulate a crash.

SimulateCrash();

ASSERT_EQ(net::OK, CreateEntry(second, &entry));

- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

EXPECT_EQ(2, cache_->GetEntryCount());

SetMaxSize(kSize);

@@ -917,7 +922,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {

for (int i = 0; i < 32; i++) {

std::string key(base::StringPrintf("some key %d", i));

ASSERT_EQ(net::OK, CreateEntry(key, &entry));

- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

entry->Close();

ASSERT_EQ(net::OK, OpenEntry(key, &entry));

// Note that we are not closing the entries.

@@ -927,7 +932,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {

SimulateCrash();

ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));

- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));

FlushQueueForTest();

EXPECT_EQ(33, cache_->GetEntryCount());

@@ -1111,10 +1116,10 @@ void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {

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));

+ EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));

entry1->Close();

ASSERT_EQ(net::OK, OpenEntry(key, &entry1));

- EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));

+ EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));

std::string key2("Another key");

ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));

@@ -1470,7 +1475,8 @@ TEST_F(DiskCacheTest, DeleteOld) {

disk_cache::Backend* cache;

int rv = disk_cache::BackendImpl::CreateBackend(

cache_path_, true, 0, net::DISK_CACHE, disk_cache::kNoRandom,

- cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache,

+ cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

MessageLoopHelper helper;

@@ -2195,8 +2201,8 @@ void DiskCacheBackendTest::BackendDisable4() {

const int kBufSize = 20000;

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));

+ EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));

+ EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));

// This line should disable the cache but not delete it.

EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));

@@ -2204,13 +2210,13 @@ void DiskCacheBackendTest::BackendDisable4() {

EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));

- EXPECT_EQ(100, ReadData(entry2, 0, 0, buf, 100));

- EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));

- EXPECT_EQ(100, WriteData(entry2, 1, 0, buf, 100, false));

+ EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));

+ EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));

+ EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));

- EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf, kBufSize));

- EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));

- EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf, kBufSize, false));

+ EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));

+ EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));

+ EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));

std::string key = entry2->GetKey();

EXPECT_EQ(sizeof(key2) - 1, key.size());

@@ -2249,8 +2255,8 @@ TEST_F(DiskCacheTest, Backend_UsageStats) {

ASSERT_TRUE(CleanupCacheDir());

scoped_ptr<disk_cache::BackendImpl> cache;

cache.reset(new disk_cache::BackendImpl(

- cache_path_, base::MessageLoopProxy::current(),

- NULL));

+ cache_path_, base::MessageLoopProxy::current().get(),

+ NULL));

ASSERT_TRUE(NULL != cache.get());

cache->SetUnitTestMode();

ASSERT_EQ(net::OK, cache->SyncInit());

@@ -2370,11 +2376,11 @@ TEST_F(DiskCacheTest, MultipleInstances) {

int rv = disk_cache::BackendImpl::CreateBackend(

store1.path(), false, 0, net::DISK_CACHE, disk_cache::kNone,

- cache_thread.message_loop_proxy(), NULL, &cache[0], cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache[0], cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

rv = disk_cache::BackendImpl::CreateBackend(

store2.path(), false, 0, net::MEDIA_CACHE, disk_cache::kNone,

- cache_thread.message_loop_proxy(), NULL, &cache[1], cb.callback());

+ cache_thread.message_loop_proxy().get(), NULL, &cache[1], cb.callback());

ASSERT_EQ(net::OK, cb.GetResult(rv));

ASSERT_TRUE(cache[0] != NULL && cache[1] != NULL);

@@ -2467,14 +2473,16 @@ TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {

for (int i = 0; i < 10; i++) {

SCOPED_TRACE(i);

// Allocate 2MB for this entry.

- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, true));

- EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer, kSize, true));

- EXPECT_EQ(kSize, WriteData(entry, 0, 1024 * 1024, buffer, kSize, false));

- EXPECT_EQ(kSize, WriteData(entry, 1, 1024 * 1024, buffer, kSize, false));

+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, true));

+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));

+ EXPECT_EQ(

+ kSize, WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));

+ EXPECT_EQ(

+ kSize, WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));

// Delete one of the buffers and truncate the other.

- EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));

- EXPECT_EQ(0, WriteData(entry, 1, 10, buffer, 0, true));

+ EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));

+ EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 0, true));

// Delete the second buffer, writing 10 bytes to disk.

entry->Close();

« no previous file with comments | « net/curvecp/test_server.cc ('k') | net/disk_cache/entry_impl.cc » ('j') | no next file with comments »