**STILLBAKING** Decouple disk cache tests from backends.

net/disk_cache/entry_sync_tests.cc

Index: net/disk_cache/entry_sync_tests.cc
diff --git a/net/disk_cache/entry_sync_tests.cc b/net/disk_cache/entry_sync_tests.cc
new file mode 100644
index 0000000000000000000000000000000000000000..debb0bc80d5c6050ebf09d0e75887ad2aab31ddd
--- /dev/null
+++ b/net/disk_cache/entry_sync_tests.cc
@@ -0,0 +1,179 @@
+// Copyright (c) 2014 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 "net/disk_cache/entry_sync_tests.h"
+
+#include "base/bind.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "base/strings/string_util.h"
+#include "base/time/time.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/disk_cache/disk_cache_test.h"
+#include "net/disk_cache/disk_cache_test_util.h"
+
+namespace disk_cache {
+
+namespace {
+
+void InternalSyncIOBackground(Entry* entry) {
+  const int kSize1 = 10;
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
+  CacheTestFillBuffer(buffer1->data(), kSize1, false);
+  EXPECT_EQ(
+      0,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  base::strlcpy(buffer1->data(), "the data", kSize1);
+  EXPECT_EQ(10,
+            entry->WriteData(
+                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  memset(buffer1->data(), 0, kSize1);
+  EXPECT_EQ(
+      10,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_STREQ("the data", buffer1->data());
+
+  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));
+  memset(buffer3->data(), 0, kSize3);
+  CacheTestFillBuffer(buffer2->data(), kSize2, false);
+  base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
+  EXPECT_EQ(
+      5000,
+      entry->WriteData(
+          1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false));
+  memset(buffer2->data(), 0, kSize2);
+  EXPECT_EQ(4989,
+            entry->ReadData(
+                1, 1511, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_STREQ("big data goes here", buffer2->data());
+  EXPECT_EQ(
+      5000,
+      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
+  EXPECT_EQ(1500,
+            entry->ReadData(
+                1, 5000, buffer2.get(), kSize2, net::CompletionCallback()));
+
+  EXPECT_EQ(0,
+            entry->ReadData(
+                1, 6500, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      6500,
+      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
+  EXPECT_EQ(8192,
+            entry->WriteData(
+                1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
+  EXPECT_EQ(
+      8192,
+      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
+  EXPECT_EQ(8192, entry->GetDataSize(1));
+
+  // We need to delete the memory buffer on this thread.
+  EXPECT_EQ(0, entry->WriteData(
+      0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0, entry->WriteData(
+      1, 0, NULL, 0, net::CompletionCallback(), true));
+}
+
+TEST_P(DiskCacheEntrySyncTest, InternalSyncIO) {
+  InitCache();
+
+  Entry* entry = NULL;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_TRUE(NULL != entry);
+
+  net::TestCompletionCallback cb;
+
+  // The bulk of the test runs from within the callback, on the cache thread.
+  GetCacheThread()->PostTaskAndReply(FROM_HERE,
+                                    base::Bind(&InternalSyncIOBackground, entry),
+                                    base::Bind(cb.callback(), net::OK));
+  EXPECT_EQ(net::OK, cb.WaitForResult());
+
+  entry->Doom();
+  entry->Close();
+  FlushQueueForTest();
+  EXPECT_EQ(0, cache()->GetEntryCount());
+}
+
+void ExternalSyncIOBackground(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));
+  CacheTestFillBuffer(buffer1->data(), kSize1, false);
+  CacheTestFillBuffer(buffer2->data(), kSize2, false);
+  base::strlcpy(buffer1->data(), "the data", kSize1);
+  EXPECT_EQ(17000,
+            entry->WriteData(
+                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  memset(buffer1->data(), 0, kSize1);
+  EXPECT_EQ(
+      17000,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_STREQ("the data", buffer1->data());
+
+  base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
+  EXPECT_EQ(
+      25000,
+      entry->WriteData(
+          1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false));
+  memset(buffer2->data(), 0, kSize2);
+  EXPECT_EQ(24989,
+            entry->ReadData(
+                1, 10011, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_STREQ("big data goes here", buffer2->data());
+  EXPECT_EQ(
+      25000,
+      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(5000,
+            entry->ReadData(
+                1, 30000, buffer2.get(), kSize2, net::CompletionCallback()));
+
+  EXPECT_EQ(0,
+            entry->ReadData(
+                1, 35000, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      17000,
+      entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_EQ(
+      17000,
+      entry->WriteData(
+          1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(37000, entry->GetDataSize(1));
+
+  // We need to delete the memory buffer on this thread.
+  EXPECT_EQ(0, entry->WriteData(
+      0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0, entry->WriteData(
+      1, 0, NULL, 0, net::CompletionCallback(), true));
+}
+
+TEST_P(DiskCacheEntrySyncTest, ExternalSyncIO) {
+  InitCache();
+
+  Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+
+  net::TestCompletionCallback cb;
+
+  // The bulk of the test runs from within the callback, on the cache thread.
+  GetCacheThread()->PostTaskAndReply(FROM_HERE,
+                                  base::Bind(&ExternalSyncIOBackground, entry),
+                                  base::Bind(cb.callback(), net::OK));
+  EXPECT_EQ(net::OK, cb.WaitForResult());
+
+  entry->Doom();
+  entry->Close();
+  FlushQueueForTest();
+  EXPECT_EQ(0, cache()->GetEntryCount());
+}
+
+}  // namespace
+
+}  // namespace disk_cache