Mojofy unittests related to service workers

content/browser/service_worker/service_worker_cache_writer_unittest.cc

Index: content/browser/service_worker/service_worker_cache_writer_unittest.cc
diff --git a/content/browser/service_worker/service_worker_cache_writer_unittest.cc b/content/browser/service_worker/service_worker_cache_writer_unittest.cc
index d6f3730695a8526cc14a9f5e6b4fcef7f1788d84..2a9b464eaa42d2ad161850151102f046189ca2bd 100644
--- a/content/browser/service_worker/service_worker_cache_writer_unittest.cc
+++ b/content/browser/service_worker/service_worker_cache_writer_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -399,13 +400,16 @@ class ServiceWorkerCacheWriterTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheWriterTest);
 };
 
+class ServiceWorkerCacheWriterTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerCacheWriterTest> {};
+
 // Passthrough tests:
 // In these tests, the ServiceWorkerCacheWriter under test has no existing
 // reader, since no calls to ExpectReader() have been made; this means that
 // there is no existing cached response and the incoming data is written back to
 // the cache directly.
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersSync) {
   const size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(kHeaderSize, false);
@@ -418,7 +422,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersSync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersAsync) {
   size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(kHeaderSize, true);
@@ -434,7 +438,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersAsync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataSync) {
   const std::string data1 = "abcdef";
   const std::string data2 = "ghijklmno";
   size_t response_size = data1.size() + data2.size();
@@ -456,7 +460,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataSync) {
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataAsync) {
   const std::string data1 = "abcdef";
   const std::string data2 = "ghijklmno";
   size_t response_size = data1.size() + data2.size();
@@ -484,7 +488,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataAsync) {
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersFailSync) {
   const size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, false, net::ERR_FAILED);
@@ -497,7 +501,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailSync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersFailAsync) {
   size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, true, net::ERR_FAILED);
@@ -513,7 +517,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailAsync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataFailSync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
@@ -526,7 +530,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailSync) {
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataFailAsync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
@@ -548,7 +552,7 @@ TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailAsync) {
 // reader for an existing cached response, so it will compare the response being
 // written to it against the existing cached response.
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareHeadersSync) {
   size_t response_size = 3;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
@@ -562,7 +566,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersSync) {
   EXPECT_TRUE(reader->AllExpectedReadsDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataOkSync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
@@ -584,7 +588,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkSync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareHeadersFailSync) {
   size_t response_size = 3;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
@@ -597,7 +601,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersFailSync) {
   EXPECT_TRUE(reader->AllExpectedReadsDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataFailSync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
@@ -618,7 +622,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareDataFailSync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareShortCacheReads) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareShortCacheReads) {
   const size_t kHeaderSize = 16;
   const std::string& data1 = "abcdef";
   const std::string& cache_data2 = "ghi";
@@ -648,7 +652,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareShortCacheReads) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataOkAsync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
@@ -670,7 +674,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkAsync) {
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataManyOkAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataManyOkAsync) {
   const std::string expected_data[] = {
       "abcdef", "ghijkl", "mnopqr", "stuvwxyz",
   };
@@ -705,7 +709,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareDataManyOkAsync) {
 // differs in the cached version. The writer should be asked to rewrite the
 // headers and body with the new value, and the copy reader should be asked to
 // read the header and data1.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopySync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopySync) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "ghijkl";
   std::string net_data2 = "mnopqr";
@@ -746,7 +750,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopySync) {
 }
 
 // Tests behavior when the cached data is shorter than the network data.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyShort) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopyShort) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "mnop";
   std::string net_data2 = "mnopqr";
@@ -788,7 +792,7 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyShort) {
 }
 
 // Tests behavior when the cached data is longer than the network data.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyLong) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopyLong) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "mnop";
   std::string net_data2 = "mnop";
@@ -831,5 +835,9 @@ TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyLong) {
   EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
 }
 
+INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheWriterTest,
+                        ServiceWorkerCacheWriterTestP,
+                        testing::Bool());
+
 }  // namespace
 }  // namespace content