net/disk_cache/blockfile/disk_cache_perftest.cc - Issue 992733002: Remove //net (except for Android test stuff) and sdch

Unified Diff: net/disk_cache/blockfile/disk_cache_perftest.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 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/blockfile/disk_cache_perftest.cc

diff --git a/net/disk_cache/blockfile/disk_cache_perftest.cc b/net/disk_cache/blockfile/disk_cache_perftest.cc

deleted file mode 100644

index 9aaa7f407b1aa62c049419154302adbcf6adf38a..0000000000000000000000000000000000000000

--- a/net/disk_cache/blockfile/disk_cache_perftest.cc

+++ /dev/null

@@ -1,261 +0,0 @@

-// 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/bind.h"

-#include "base/bind_helpers.h"

-#include "base/hash.h"

-#include "base/strings/string_util.h"

-#include "base/test/perf_time_logger.h"

-#include "base/test/test_file_util.h"

-#include "base/threading/thread.h"

-#include "net/base/cache_type.h"

-#include "net/base/io_buffer.h"

-#include "net/base/net_errors.h"

-#include "net/base/test_completion_callback.h"

-#include "net/disk_cache/blockfile/backend_impl.h"

-#include "net/disk_cache/blockfile/block_files.h"

-#include "net/disk_cache/disk_cache.h"

-#include "net/disk_cache/disk_cache_test_base.h"

-#include "net/disk_cache/disk_cache_test_util.h"

-#include "testing/gtest/include/gtest/gtest.h"

-#include "testing/platform_test.h"

-using base::Time;

-namespace {

-struct TestEntry {

- std::string key;

- 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.

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

- CacheTestFillBuffer(buffer1->data(), kSize1, false);

- CacheTestFillBuffer(buffer2->data(), kMaxSize, false);

- int expected = 0;

- MessageLoopHelper helper;

- CallbackTest callback(&helper, true);

- base::PerfTimeLogger timer("Write disk cache entries");

- for (int i = 0; i < num_entries; i++) {

- TestEntry entry;

- entry.key = GenerateKey(true);

- entry.data_len = rand() % kMaxSize;

- entries->push_back(entry);

- disk_cache::Entry* cache_entry;

- net::TestCompletionCallback cb;

- int rv = cache->CreateEntry(entry.key, &cache_entry, cb.callback());

- if (net::OK != cb.GetResult(rv))

- break;

- int ret = cache_entry->WriteData(

- 0, 0, buffer1.get(), kSize1,

- base::Bind(&CallbackTest::Run, base::Unretained(&callback)), false);

- if (net::ERR_IO_PENDING == ret)

- expected++;

- else if (kSize1 != ret)

- break;

- ret = cache_entry->WriteData(

- 1, 0, buffer2.get(), entry.data_len,

- base::Bind(&CallbackTest::Run, base::Unretained(&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 == helper.callbacks_called());

-// Reads the data and metadata from each entry listed on |entries|.

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

- CacheTestFillBuffer(buffer1->data(), kSize1, false);

- CacheTestFillBuffer(buffer2->data(), kMaxSize, false);

- int expected = 0;

- MessageLoopHelper helper;

- CallbackTest callback(&helper, true);

- const char* message = cold ? "Read disk cache entries (cold)" :

- "Read disk cache entries (warm)";

- base::PerfTimeLogger timer(message);

- for (int i = 0; i < num_entries; i++) {

- disk_cache::Entry* cache_entry;

- net::TestCompletionCallback cb;

- int rv = cache->OpenEntry(entries[i].key, &cache_entry, cb.callback());

- if (net::OK != cb.GetResult(rv))

- break;

- int ret = cache_entry->ReadData(

- 0, 0, buffer1.get(), kSize1,

- base::Bind(&CallbackTest::Run, base::Unretained(&callback)));

- if (net::ERR_IO_PENDING == ret)

- expected++;

- else if (kSize1 != ret)

- break;

- ret = cache_entry->ReadData(

- 1, 0, buffer2.get(), entries[i].data_len,

- base::Bind(&CallbackTest::Run, base::Unretained(&callback)));

- if (net::ERR_IO_PENDING == ret)

- expected++;

- else if (entries[i].data_len != ret)

- break;

- cache_entry->Close();

- }

- helper.WaitUntilCacheIoFinished(expected);

- timer.Done();

- return (expected == helper.callbacks_called());

-int BlockSize() {

- // We can use form 1 to 4 blocks.

- return (rand() & 0x3) + 1;

-} // namespace

-TEST_F(DiskCacheTest, Hash) {

- int seed = static_cast<int>(Time::Now().ToInternalValue());

- srand(seed);

- base::PerfTimeLogger timer("Hash disk cache keys");

- for (int i = 0; i < 300000; i++) {

- std::string key = GenerateKey(true);

- base::Hash(key);

- }

- timer.Done();

-TEST_F(DiskCacheTest, CacheBackendPerformance) {

- base::Thread cache_thread("CacheThread");

- ASSERT_TRUE(cache_thread.StartWithOptions(

- base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));

- ASSERT_TRUE(CleanupCacheDir());

- net::TestCompletionCallback cb;

- scoped_ptr<disk_cache::Backend> cache;

- int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,

- net::CACHE_BACKEND_BLOCKFILE,

- cache_path_,

- 0,

- false,

- cache_thread.task_runner(),

- NULL,

- &cache,

- cb.callback());

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

- int seed = static_cast<int>(Time::Now().ToInternalValue());

- srand(seed);

- TestEntries entries;

- int num_entries = 1000;

- EXPECT_TRUE(TimeWrite(num_entries, cache.get(), &entries));

- base::MessageLoop::current()->RunUntilIdle();

- cache.reset();