Refactor net tests to use GMock matchers for checking net::Error results

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 10 matching lines @@
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/memory/mem_entry_impl.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_test_util.h"
 #include "net/disk_cache/simple/simple_util.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 using base::Time;
 using disk_cache::ScopedEntryPtr;
 
 // Tests that can run with different types of caches.
 class DiskCacheEntryTest : public DiskCacheTestWithCache {
  public:
   void InternalSyncIOBackground(disk_cache::Entry* entry);
   void ExternalSyncIOBackground(disk_cache::Entry* entry);
 
  protected:
@@ skipping 91 matching lines @@
   EXPECT_EQ(0, entry->WriteData(
       1, 0, NULL, 0, net::CompletionCallback(), true));
 }
 
 // We need to support synchronous IO even though it is not a supported operation
 // from the point of view of the disk cache's public interface, because we use
 // it internally, not just by a few tests, but as part of the implementation
 // (see sparse_control.cc, for example).
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
   ASSERT_TRUE(NULL != entry);
 
   // The bulk of the test runs from within the callback, on the cache thread.
   RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground,
                             base::Unretained(this),
                             entry));
 
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalSyncIO) {
   InitCache();
   InternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalSyncIO();
 }
 
 void DiskCacheEntryTest::InternalAsyncIO() {
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
   ASSERT_TRUE(NULL != entry);
 
   // Avoid using internal buffers for the test. We have to write something to
   // the entry and close it so that we flush the internal buffer to disk. After
   // that, IO operations will be really hitting the disk. We don't care about
   // the content, so just extending the entry is enough (all extensions zero-
   // fill any holes).
   EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false));
   EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false));
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
+  ASSERT_THAT(OpenEntry("the first key", &entry), IsOk());
 
   MessageLoopHelper helper;
   // Let's verify that each IO goes to the right callback object.
   CallbackTest callback1(&helper, false);
   CallbackTest callback2(&helper, false);
   CallbackTest callback3(&helper, false);
   CallbackTest callback4(&helper, false);
   CallbackTest callback5(&helper, false);
   CallbackTest callback6(&helper, false);
   CallbackTest callback7(&helper, false);
@@ skipping 223 matching lines @@
 
   // 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));
 }
 
 void DiskCacheEntryTest::ExternalSyncIO() {
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
 
   // The bulk of the test runs from within the callback, on the cache thread.
   RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground,
                             base::Unretained(this),
                             entry));
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
@@ skipping 11 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalSyncIO();
 }
 
 void DiskCacheEntryTest::ExternalAsyncIO() {
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
 
   int expected = 0;
 
   MessageLoopHelper helper;
   // Let's verify that each IO goes to the right callback object.
   CallbackTest callback1(&helper, false);
   CallbackTest callback2(&helper, false);
   CallbackTest callback3(&helper, false);
   CallbackTest callback4(&helper, false);
   CallbackTest callback5(&helper, false);
@@ skipping 146 matching lines @@
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 // Tests that IOBuffers are not referenced after IO completes.
 void DiskCacheEntryTest::ReleaseBuffer(int stream_index) {
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
   ASSERT_TRUE(NULL != entry);
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(buffer->data(), kBufferSize, false);
 
   net::ReleaseBufferCompletionCallback cb(buffer.get());
   int rv = entry->WriteData(
       stream_index, 0, buffer.get(), kBufferSize, cb.callback(), false);
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReleaseBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ReleaseBuffer(0);
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) {
   SetMemoryOnlyMode();
   InitCache();
   ReleaseBuffer(0);
 }
 
 void DiskCacheEntryTest::StreamAccess() {
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_THAT(CreateEntry("the first key", &entry), IsOk());
   ASSERT_TRUE(NULL != entry);
 
   const int kBufferSize = 1024;
   const int kNumStreams = 3;
   scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams];
   for (int i = 0; i < kNumStreams; i++) {
     reference_buffers[i] = new net::IOBuffer(kBufferSize);
     CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false);
   }
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
     EXPECT_EQ(
         kBufferSize,
         WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false));
     memset(buffer1->data(), 0, kBufferSize);
     EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
     EXPECT_EQ(
         0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize));
   }
   EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
             ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
   entry->Close();
 
   // Open the entry and read it in chunks, including a read past the end.
-  ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
+  ASSERT_THAT(OpenEntry("the first key", &entry), IsOk());
   ASSERT_TRUE(NULL != entry);
   const int kReadBufferSize = 600;
   const int kFinalReadSize = kBufferSize - kReadBufferSize;
   static_assert(kFinalReadSize < kReadBufferSize,
                 "should be exactly two reads");
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
     memset(buffer2->data(), 0, kReadBufferSize);
     EXPECT_EQ(kReadBufferSize,
               ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
@@ skipping 21 matching lines @@
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) {
   SetMemoryOnlyMode();
   InitCache();
   StreamAccess();
 }
 
 void DiskCacheEntryTest::GetKey() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_EQ(key, entry->GetKey()) << "short key";
   entry->Close();
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
   char key_buffer[20000];
 
   CacheTestFillBuffer(key_buffer, 3000, true);
   key_buffer[1000] = '\0';
 
   key = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
   entry->Close();
 
   key_buffer[1000] = 'p';
   key_buffer[3000] = '\0';
   key = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
   entry->Close();
 
   CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
   key_buffer[19999] = '\0';
 
   key = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(key == entry->GetKey()) << "long key";
   entry->Close();
 
   CacheTestFillBuffer(key_buffer, 0x4000, true);
   key_buffer[0x4000] = '\0';
 
   key = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(key == entry->GetKey()) << "16KB key";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetKey) {
   InitCache();
   GetKey();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) {
   SetMemoryOnlyMode();
   InitCache();
   GetKey();
 }
 
 void DiskCacheEntryTest::GetTimes(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
 
   Time t1 = Time::Now();
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(entry->GetLastModified() >= t1);
   EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
 
   AddDelay();
   Time t2 = Time::Now();
   EXPECT_TRUE(t2 > t1);
   EXPECT_EQ(0, WriteData(entry, stream_index, 200, NULL, 0, false));
   if (type_ == net::APP_CACHE) {
     EXPECT_TRUE(entry->GetLastModified() < t2);
   } else {
@@ skipping 39 matching lines @@
 
 TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes) {
   SetCacheType(net::SHADER_CACHE);
   InitCache();
   GetTimes(0);
 }
 
 void DiskCacheEntryTest::GrowData(int stream_index) {
   std::string key1("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
+  ASSERT_THAT(CreateEntry(key1, &entry), IsOk());
 
   const int kSize = 20000;
   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);
 
   base::strlcpy(buffer1->data(), "the data", kSize);
   EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
   EXPECT_EQ(10, ReadData(entry, stream_index, 0, buffer2.get(), 10));
   EXPECT_STREQ("the data", buffer2->data());
   EXPECT_EQ(10, entry->GetDataSize(stream_index));
 
   EXPECT_EQ(2000,
             WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
   EXPECT_EQ(2000, entry->GetDataSize(stream_index));
   EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
 
   EXPECT_EQ(20000,
             WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
   EXPECT_EQ(20000, entry->GetDataSize(stream_index));
   EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
 
   memset(buffer2->data(), 0, kSize);
   std::string key2("Second key");
-  ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
+  ASSERT_THAT(CreateEntry(key2, &entry), IsOk());
   EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
   EXPECT_EQ(10, entry->GetDataSize(stream_index));
   entry->Close();
 
   // Go from an internal address to a bigger block size.
-  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  ASSERT_THAT(OpenEntry(key2, &entry), IsOk());
   EXPECT_EQ(2000,
             WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
   EXPECT_EQ(2000, entry->GetDataSize(stream_index));
   EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
   entry->Close();
   memset(buffer2->data(), 0, kSize);
 
   // Go from an internal address to an external one.
-  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  ASSERT_THAT(OpenEntry(key2, &entry), IsOk());
   EXPECT_EQ(20000,
             WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
   EXPECT_EQ(20000, entry->GetDataSize(stream_index));
   EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
 
   // Double check the size from disk.
-  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  ASSERT_THAT(OpenEntry(key2, &entry), IsOk());
   EXPECT_EQ(20000, entry->GetDataSize(stream_index));
 
   // Now extend the entry without actual data.
   EXPECT_EQ(0, WriteData(entry, stream_index, 45500, buffer1.get(), 0, false));
   entry->Close();
 
   // And check again from disk.
-  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  ASSERT_THAT(OpenEntry(key2, &entry), IsOk());
   EXPECT_EQ(45500, entry->GetDataSize(stream_index));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GrowData) {
   InitCache();
   GrowData(0);
 }
 
 TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   GrowData(0);
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) {
   SetMemoryOnlyMode();
   InitCache();
   GrowData(0);
 }
 
 void DiskCacheEntryTest::TruncateData(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   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));
 
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
   // Simple truncation:
   EXPECT_EQ(200, WriteData(entry, stream_index, 0, buffer1.get(), 200, false));
   EXPECT_EQ(200, entry->GetDataSize(stream_index));
   EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, false));
   EXPECT_EQ(200, entry->GetDataSize(stream_index));
   EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, true));
   EXPECT_EQ(100, entry->GetDataSize(stream_index));
   EXPECT_EQ(0, WriteData(entry, stream_index, 50, buffer1.get(), 0, true));
   EXPECT_EQ(50, entry->GetDataSize(stream_index));
   EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true));
   EXPECT_EQ(0, entry->GetDataSize(stream_index));
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   // Go to an external file.
   EXPECT_EQ(20000,
             WriteData(entry, stream_index, 0, buffer1.get(), 20000, true));
   EXPECT_EQ(20000, entry->GetDataSize(stream_index));
   EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), 20000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
   memset(buffer2->data(), 0, kSize2);
 
   // External file truncation
@@ skipping 39 matching lines @@
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
   SetMemoryOnlyMode();
   InitCache();
   TruncateData(0);
 }
 
 void DiskCacheEntryTest::ZeroLengthIO(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   EXPECT_EQ(0, ReadData(entry, stream_index, 0, NULL, 0));
   EXPECT_EQ(0, WriteData(entry, stream_index, 0, NULL, 0, false));
 
   // This write should extend the entry.
   EXPECT_EQ(0, WriteData(entry, stream_index, 1000, NULL, 0, false));
   EXPECT_EQ(0, ReadData(entry, stream_index, 500, NULL, 0));
   EXPECT_EQ(0, ReadData(entry, stream_index, 2000, NULL, 0));
   EXPECT_EQ(1000, entry->GetDataSize(stream_index));
 
@@ skipping 36 matching lines @@
   SetMemoryOnlyMode();
   InitCache();
   ZeroLengthIO(0);
 }
 
 // Tests that we handle the content correctly when buffering, a feature of the
 // standard cache that permits fast responses to certain reads.
 void DiskCacheEntryTest::Buffering() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 200;
   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);
 
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
   entry->Close();
 
   // Write a little more and read what we wrote before.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
   EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Now go to an external file.
   EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
   entry->Close();
 
   // Write something else and verify old data.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Extend the file some more.
   EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
   entry->Close();
 
   // And now make sure that we can deal with data in both places (ram/disk).
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));
 
   // We should not overwrite the data at 18000 with this.
   EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
@@ skipping 28 matching lines @@
 TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   Buffering();
 }
 
 // Checks that entries are zero length when created.
 void DiskCacheEntryTest::SizeAtCreate() {
   const char key[]  = "the first key";
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kNumStreams = 3;
   for (int i = 0; i < kNumStreams; ++i)
     EXPECT_EQ(0, entry->GetDataSize(i));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeAtCreate) {
   InitCache();
   SizeAtCreate();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) {
   SetMemoryOnlyMode();
   InitCache();
   SizeAtCreate();
 }
 
 // Some extra tests to make sure that buffering works properly when changing
 // the entry size.
 void DiskCacheEntryTest::SizeChanges(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   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));
   CacheTestFillBuffer(buffer1->data(), kSize, true);
   CacheTestFillBuffer(buffer2->data(), kSize, true);
 
   EXPECT_EQ(kSize,
             WriteData(entry, stream_index, 0, buffer1.get(), kSize, true));
   EXPECT_EQ(kSize,
             WriteData(entry, stream_index, 17000, buffer1.get(), kSize, true));
   EXPECT_EQ(kSize,
             WriteData(entry, stream_index, 23000, buffer1.get(), kSize, true));
   entry->Close();
 
   // Extend the file and read between the old size and the new write.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(23000 + kSize, entry->GetDataSize(stream_index));
   EXPECT_EQ(kSize,
             WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true));
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
   EXPECT_EQ(kSize, ReadData(entry, stream_index, 24000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
 
   // Read at the end of the old file size.
   EXPECT_EQ(
       kSize,
@@ skipping 38 matching lines @@
   // And now reduce the size below the old size.
   EXPECT_EQ(kSize,
             WriteData(entry, stream_index, 19000, buffer1.get(), kSize, true));
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));
   EXPECT_EQ(kSize, ReadData(entry, stream_index, 18900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // Verify that the actual file is truncated.
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));
 
   // Extend the newly opened file with a zero length write, expect zero fill.
   EXPECT_EQ(
       0,
       WriteData(entry, stream_index, 20000 + kSize, buffer1.get(), 0, false));
   EXPECT_EQ(kSize,
             ReadData(entry, stream_index, 19000 + kSize, buffer1.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeChanges) {
   InitCache();
   SizeChanges(1);
 }
 
 TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   SizeChanges(1);
 }
 
 // Write more than the total cache capacity but to a single entry. |size| is the
 // amount of bytes to write each time.
 void DiskCacheEntryTest::ReuseEntry(int size, int stream_index) {
   std::string key1("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
+  ASSERT_THAT(CreateEntry(key1, &entry), IsOk());
 
   entry->Close();
   std::string key2("the second key");
-  ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
+  ASSERT_THAT(CreateEntry(key2, &entry), IsOk());
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
   CacheTestFillBuffer(buffer->data(), size, false);
 
   for (int i = 0; i < 15; i++) {
     EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer.get(), 0, true));
     EXPECT_EQ(size,
               WriteData(entry, stream_index, 0, buffer.get(), size, false));
     entry->Close();
-    ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+    ASSERT_THAT(OpenEntry(key2, &entry), IsOk());
   }
 
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) {
   SetMaxSize(200 * 1024);
   InitCache();
@@ skipping 17 matching lines @@
   SetMemoryOnlyMode();
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024, 0);
 }
 
 // Reading somewhere that was not written should return zeros.
 void DiskCacheEntryTest::InvalidData(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   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));
 
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
   // Simple data grow:
   EXPECT_EQ(200,
             WriteData(entry, stream_index, 400, buffer1.get(), 200, false));
   EXPECT_EQ(600, entry->GetDataSize(stream_index));
   EXPECT_EQ(100, ReadData(entry, stream_index, 300, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   // The entry is now on disk. Load it and extend it.
   EXPECT_EQ(200,
             WriteData(entry, stream_index, 800, buffer1.get(), 200, false));
   EXPECT_EQ(1000, entry->GetDataSize(stream_index));
   EXPECT_EQ(100, ReadData(entry, stream_index, 700, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   // This time using truncate.
   EXPECT_EQ(200,
             WriteData(entry, stream_index, 1800, buffer1.get(), 200, true));
   EXPECT_EQ(2000, entry->GetDataSize(stream_index));
   EXPECT_EQ(100, ReadData(entry, stream_index, 1500, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
 
   // Go to an external file.
   EXPECT_EQ(200,
@@ skipping 40 matching lines @@
 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
   SetMemoryOnlyMode();
   InitCache();
   InvalidData(0);
 }
 
 // Tests that the cache preserves the buffer of an IO operation.
 void DiskCacheEntryTest::ReadWriteDestroyBuffer(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 200;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
   net::TestCompletionCallback cb;
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->WriteData(
                 stream_index, 0, buffer.get(), kSize, cb.callback(), false));
 
@@ skipping 15 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) {
   InitCache();
   ReadWriteDestroyBuffer(0);
 }
 
 void DiskCacheEntryTest::DoomNormalEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Doom();
   entry->Close();
 
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, true);
   buffer->data()[19999] = '\0';
 
   key = buffer->data();
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
   entry->Doom();
   entry->Close();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntry) {
   InitCache();
   DoomNormalEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomNormalEntry();
 }
 
 // Tests dooming an entry that's linked to an open entry.
 void DiskCacheEntryTest::DoomEntryNextToOpenEntry() {
   disk_cache::Entry* entry1;
   disk_cache::Entry* entry2;
-  ASSERT_EQ(net::OK, CreateEntry("fixed", &entry1));
+  ASSERT_THAT(CreateEntry("fixed", &entry1), IsOk());
   entry1->Close();
-  ASSERT_EQ(net::OK, CreateEntry("foo", &entry1));
+  ASSERT_THAT(CreateEntry("foo", &entry1), IsOk());
   entry1->Close();
-  ASSERT_EQ(net::OK, CreateEntry("bar", &entry1));
+  ASSERT_THAT(CreateEntry("bar", &entry1), IsOk());
   entry1->Close();
 
-  ASSERT_EQ(net::OK, OpenEntry("foo", &entry1));
-  ASSERT_EQ(net::OK, OpenEntry("bar", &entry2));
+  ASSERT_THAT(OpenEntry("foo", &entry1), IsOk());
+  ASSERT_THAT(OpenEntry("bar", &entry2), IsOk());
   entry2->Doom();
   entry2->Close();
 
-  ASSERT_EQ(net::OK, OpenEntry("foo", &entry2));
+  ASSERT_THAT(OpenEntry("foo", &entry2), IsOk());
   entry2->Doom();
   entry2->Close();
   entry1->Close();
 
-  ASSERT_EQ(net::OK, OpenEntry("fixed", &entry1));
+  ASSERT_THAT(OpenEntry("fixed", &entry1), IsOk());
   entry1->Close();
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) {
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
 TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) {
   SetNewEviction();
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
 TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) {
   SetCacheType(net::APP_CACHE);
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
 // Verify that basic operations work as expected with doomed entries.
 void DiskCacheEntryTest::DoomedEntry(int stream_index) {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Doom();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
   Time initial = Time::Now();
   AddDelay();
 
   const int kSize1 = 2000;
   const int kSize2 = 2000;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
@@ skipping 22 matching lines @@
   InitCache();
   DoomedEntry(0);
 }
 
 // Tests that we discard entries if the data is missing.
 TEST_F(DiskCacheEntryTest, MissingData) {
   InitCache();
 
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   // Write to an external file.
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   entry->Close();
   FlushQueueForTest();
 
   disk_cache::Addr address(0x80000001);
   base::FilePath name = cache_impl_->GetFileName(address);
   EXPECT_TRUE(base::DeleteFile(name, false));
 
   // Attempt to read the data.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
             ReadData(entry, 0, 0, buffer.get(), kSize));
   entry->Close();
 
   // The entry should be gone.
   ASSERT_NE(net::OK, OpenEntry(key, &entry));
 }
 
 // Test that child entries in a memory cache backend are not visible from
 // enumerations.
 TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 4096;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* parent_entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry));
+  ASSERT_THAT(CreateEntry(key, &parent_entry), IsOk());
 
   // Writes to the parent entry.
   EXPECT_EQ(kSize,
             parent_entry->WriteSparseData(
                 0, buf.get(), kSize, net::CompletionCallback()));
 
   // This write creates a child entry and writes to it.
   EXPECT_EQ(kSize,
             parent_entry->WriteSparseData(
                 8192, buf.get(), kSize, net::CompletionCallback()));
@@ skipping 47 matching lines @@
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
   memset(buf_1->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
 void DiskCacheEntryTest::BasicSparseIO() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 2048;
   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.
   VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get());
 
   // Write at offset 0x400000 (4 MB).
   VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get());
 
   // Write at offset 0x800000000 (32 GB).
   VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get());
 
   entry->Close();
 
   // Check everything again.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize);
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, BasicSparseIO) {
   InitCache();
   BasicSparseIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
   BasicSparseIO();
 }
 
 void DiskCacheEntryTest::HugeSparseIO() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   // 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));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
   VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get());
   entry->Close();
 
   // Check it again.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, HugeSparseIO) {
   InitCache();
   HugeSparseIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
   HugeSparseIO();
 }
 
 void DiskCacheEntryTest::GetAvailableRange() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 16 * 1024;
   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).
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
 
   // We stop at the first empty block.
@@ skipping 56 matching lines @@
   InitCache();
   GetAvailableRange();
 }
 
 // Tests that non-sequential writes that are not aligned with the minimum sparse
 // data granularity (1024 bytes) do in fact result in dropped data.
 TEST_F(DiskCacheEntryTest, SparseWriteDropped) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 180;
   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);
 
   // Do small writes (180 bytes) that get increasingly close to a 1024-byte
   // boundary. All data should be dropped until a boundary is crossed, at which
   // point the data after the boundary is saved (at least for a while).
   int offset = 1024 - 500;
@@ skipping 36 matching lines @@
   rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
   entry->Close();
 }
 
 // Tests that small sequential writes are not dropped.
 TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 180;
   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);
 
   // Any starting offset is fine as long as it is 1024-bytes aligned.
   int rv = 0;
   net::TestCompletionCallback cb;
   int64_t start;
   int64_t offset = 1024 * 11;
   for (; offset < 20000; offset += kSize) {
     rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
 
     rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
     EXPECT_EQ(offset, start);
 
     rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
     EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));
   }
 
   entry->Close();
   FlushQueueForTest();
 
   // Verify again the last write made.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   offset -= kSize;
   rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(offset, start);
 
   rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));
 
   entry->Close();
 }
 
 void DiskCacheEntryTest::CouldBeSparse() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 16 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
 
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
 
   // Now verify a regular entry.
   key.assign("another key");
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_FALSE(entry->CouldBeSparse());
 
   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
   EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));
 
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, CouldBeSparse) {
   InitCache();
   CouldBeSparse();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) {
   SetMemoryOnlyMode();
   InitCache();
   CouldBeSparse();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
   SetMemoryOnlyMode();
   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));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   // 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));
     VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
     VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
   }
 
   // Make sure we have data written.
   VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
 
   // This tests a large write that spans 3 entries from a misaligned offset.
   VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 8192;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   disk_cache::Entry* entry;
   std::string key("the first key");
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   // Writes in the middle of an entry.
   EXPECT_EQ(
       1024,
       entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback()));
   EXPECT_EQ(
       1024,
       entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
   EXPECT_EQ(1024,
             entry->WriteSparseData(
@@ skipping 38 matching lines @@
   rv = entry->GetAvailableRange(40000, 20000, &start, cb.callback());
   EXPECT_EQ(8192, cb.GetResult(rv));
   EXPECT_EQ(50000, start);
 
   entry->Close();
 }
 
 void DiskCacheEntryTest::UpdateSparseEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+  ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
 
   const int kSize = 2048;
   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.
   VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get());
   entry1->Close();
 
   // Write at offset 2048.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
+  ASSERT_THAT(OpenEntry(key, &entry1), IsOk());
   VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get());
 
   disk_cache::Entry* entry2;
-  ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2));
+  ASSERT_THAT(CreateEntry("the second key", &entry2), IsOk());
 
   entry1->Close();
   entry2->Close();
   FlushQueueForTest();
   if (memory_only_ || simple_cache_mode_)
     EXPECT_EQ(2, cache_->GetEntryCount());
   else
     EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, UpdateSparseEntry) {
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
   SetMemoryOnlyMode();
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
 void DiskCacheEntryTest::DoomSparseEntry() {
   std::string key1("the first key");
   std::string key2("the second key");
   disk_cache::Entry *entry1, *entry2;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
+  ASSERT_THAT(CreateEntry(key1, &entry1), IsOk());
+  ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   int64_t offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
     EXPECT_EQ(kSize, WriteSparseData(entry1, offset, buf.get(), kSize));
     // Keep the second map under the default size.
     if (i < 9)
       EXPECT_EQ(kSize, WriteSparseData(entry2, offset, buf.get(), kSize));
 
     offset *= 4;
   }
 
   if (memory_only_ || simple_cache_mode_)
     EXPECT_EQ(2, cache_->GetEntryCount());
   else
     EXPECT_EQ(15, cache_->GetEntryCount());
 
   // Doom the first entry while it's still open.
   entry1->Doom();
   entry1->Close();
   entry2->Close();
 
   // Doom the second entry after it's fully saved.
-  EXPECT_EQ(net::OK, DoomEntry(key2));
+  EXPECT_THAT(DoomEntry(key2), IsOk());
 
   // Make sure we do all needed work. This may fail for entry2 if between Close
   // and DoomEntry the system decides to remove all traces of the file from the
   // system cache so we don't see that there is pending IO.
   base::RunLoop().RunUntilIdle();
 
   if (memory_only_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   } else {
     if (5 == cache_->GetEntryCount()) {
@@ skipping 39 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
 };
 
 // Tests that we don't crash when the backend is deleted while we are working
 // deleting the sub-entries of a sparse entry.
 TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
   UseCurrentThread();
   InitCache();
   std::string key("the key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   int64_t offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
     EXPECT_EQ(kSize,
               entry->WriteSparseData(
                   offset, buf.get(), kSize, net::CompletionCallback()));
     offset *= 4;
   }
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   entry->Close();
   disk_cache::Backend* cache = cache_.get();
   SparseTestCompletionCallback cb(std::move(cache_));
   int rv = cache->DoomEntry(key, cb.callback());
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
-  EXPECT_EQ(net::OK, cb.WaitForResult());
+  EXPECT_THAT(rv, IsError(net::ERR_IO_PENDING));
+  EXPECT_THAT(cb.WaitForResult(), IsOk());
 }
 
 void DiskCacheEntryTest::PartialSparseEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   // We should be able to deal with IO that is not aligned to the block size
   // 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));
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   // The first write is just to extend the entry. The third write occupies
   // a 1KB block partially, it may not be written internally depending on the
   // implementation.
   EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize));
   EXPECT_EQ(kSmallSize,
             WriteSparseData(entry, 1080321, buf1.get(), kSmallSize));
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
   memset(buf2->data(), 0, kSize);
   EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize));
 
   EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
   EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize));
 
   // This read should not change anything.
@@ skipping 68 matching lines @@
   SetMemoryOnlyMode();
   InitCache();
   PartialSparseEntry();
 }
 
 // Tests that corrupt sparse children are removed automatically.
 TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   const int k1Meg = 1024 * 1024;
   EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
   entry->Close();
   EXPECT_EQ(4, cache_->GetEntryCount());
 
   std::unique_ptr<TestIterator> iter = CreateIterator();
   int count = 0;
   std::string child_key[2];
   while (iter->OpenNextEntry(&entry) == net::OK) {
     ASSERT_TRUE(entry != NULL);
     // Writing to an entry will alter the LRU list and invalidate the iterator.
     if (entry->GetKey() != key && count < 2)
       child_key[count++] = entry->GetKey();
     entry->Close();
   }
   for (int i = 0; i < 2; i++) {
-    ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
+    ASSERT_THAT(OpenEntry(child_key[i], &entry), IsOk());
     // Overwrite the header's magic and signature.
     EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
     entry->Close();
   }
 
   EXPECT_EQ(4, cache_->GetEntryCount());
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   // Two children should be gone. One while reading and one while writing.
   EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize));
   EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
 
   // We never touched this one.
   EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize));
   entry->Close();
 
   // We re-created one of the corrupt children.
   EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, CancelSparseIO) {
   UseCurrentThread();
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const int kSize = 40 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // This will open and write two "real" entries.
   net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
   int rv = entry->WriteSparseData(
       1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(net::ERR_IO_PENDING));
 
   int64_t offset = 0;
   rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
   rv = cb5.GetResult(rv);
   if (!cb1.have_result()) {
     // We may or may not have finished writing to the entry. If we have not,
     // we cannot start another operation at this time.
-    EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv);
+    EXPECT_THAT(rv, IsError(net::ERR_CACHE_OPERATION_NOT_SUPPORTED));
   }
 
   // We cancel the pending operation, and register multiple notifications.
   entry->CancelSparseIO();
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb2.callback()));
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb3.callback()));
+  EXPECT_THAT(entry->ReadyForSparseIO(cb2.callback()),
+              IsError(net::ERR_IO_PENDING));
+  EXPECT_THAT(entry->ReadyForSparseIO(cb3.callback()),
+              IsError(net::ERR_IO_PENDING));
   entry->CancelSparseIO();  // Should be a no op at this point.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb4.callback()));
+  EXPECT_THAT(entry->ReadyForSparseIO(cb4.callback()),
+              IsError(net::ERR_IO_PENDING));
 
   if (!cb1.have_result()) {
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
               entry->ReadSparseData(
                   offset, buf.get(), kSize, net::CompletionCallback()));
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
               entry->WriteSparseData(
                   offset, buf.get(), kSize, net::CompletionCallback()));
   }
 
   // Now see if we receive all notifications. Note that we should not be able
   // to write everything (unless the timing of the system is really weird).
   rv = cb1.WaitForResult();
   EXPECT_TRUE(rv == 4096 || rv == kSize);
-  EXPECT_EQ(net::OK, cb2.WaitForResult());
-  EXPECT_EQ(net::OK, cb3.WaitForResult());
-  EXPECT_EQ(net::OK, cb4.WaitForResult());
+  EXPECT_THAT(cb2.WaitForResult(), IsOk());
+  EXPECT_THAT(cb3.WaitForResult(), IsOk());
+  EXPECT_THAT(cb4.WaitForResult(), IsOk());
 
   rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
   EXPECT_EQ(0, cb5.GetResult(rv));
   entry->Close();
 }
 
 // Tests that we perform sanity checks on an entry's key. Note that there are
 // other tests that exercise sanity checks by using saved corrupt files.
 TEST_F(DiskCacheEntryTest, KeySanityCheck) {
   UseCurrentThread();
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   disk_cache::EntryImpl* entry_impl =
       static_cast<disk_cache::EntryImpl*>(entry);
   disk_cache::EntryStore* store = entry_impl->entry()->Data();
 
   // We have reserved space for a short key (one block), let's say that the key
   // takes more than one block, and remove the NULLs after the actual key.
   store->key_len = 800;
   memset(store->key + key.size(), 'k', sizeof(store->key) - key.size());
   entry_impl->entry()->set_modified();
@@ skipping 14 matching lines @@
 TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO) {
   SetSimpleCacheMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     ReleaseBuffer(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess) {
   SetSimpleCacheMode();
   InitCache();
   StreamAccess();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheGetKey) {
   SetSimpleCacheMode();
   InitCache();
   GetKey();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     GetTimes(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheGrowData) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     GrowData(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheTruncateData) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     TruncateData(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheZeroLengthIO) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     ZeroLengthIO(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheSizeAtCreate) {
   SetSimpleCacheMode();
   InitCache();
   SizeAtCreate();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReuseExternalEntry) {
   SetSimpleCacheMode();
   SetMaxSize(200 * 1024);
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     ReuseEntry(20 * 1024, i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReuseInternalEntry) {
   SetSimpleCacheMode();
   SetMaxSize(100 * 1024);
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     ReuseEntry(10 * 1024, i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheSizeChanges) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     SizeChanges(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheInvalidData) {
   SetSimpleCacheMode();
   InitCache();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     InvalidData(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReadWriteDestroyBuffer) {
   // Proving that the test works well with optimistic operations enabled is
   // subtle, instead run only in APP_CACHE mode to disable optimistic
   // operations. Stream 0 always uses optimistic operations, so the test is not
   // run on stream 0.
   SetCacheType(net::APP_CACHE);
   SetSimpleCacheMode();
   InitCache();
   for (int i = 1; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     ReadWriteDestroyBuffer(i);
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntry) {
   SetSimpleCacheMode();
   InitCache();
   DoomNormalEntry();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntryNextToOpenEntry) {
   SetSimpleCacheMode();
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry) {
   SetSimpleCacheMode();
   InitCache();
   // Stream 2 is excluded because the implementation does not support writing to
   // it on a doomed entry, if it was previously lazily omitted.
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount - 1; ++i) {
-    EXPECT_EQ(net::OK, DoomAllEntries());
+    EXPECT_THAT(DoomAllEntries(), IsOk());
     DoomedEntry(i);
   }
 }
 
 // Creates an entry with corrupted last byte in stream 0.
 // Requires SimpleCacheMode.
 bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
                                                          int* data_size) {
   disk_cache::Entry* entry = NULL;
 
@@ skipping 31 matching lines @@
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
   int size_unused;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
 
   disk_cache::Entry* entry = NULL;
 
   // Open the entry.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   ScopedEntryPtr entry_closer(entry);
 
   const int kReadBufferSize = 200;
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
             ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 }
 
 // Tests that an entry that has had an IO error occur can still be Doomed().
 TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
   int size_unused;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
 
   disk_cache::Entry* entry = NULL;
 
   // Open the entry, forcing an IO error.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   ScopedEntryPtr entry_closer(entry);
 
   const int kReadBufferSize = 200;
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
             ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 
   entry->Doom();  // Should not crash.
 }
 
 bool TruncatePath(const base::FilePath& file_path, int64_t length) {
   base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
   if (!file.IsValid())
     return false;
   return file.SetLength(length);
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) {
   SetSimpleCacheMode();
   InitCache();
 
   const std::string key("the first key");
 
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   disk_cache::Entry* null = NULL;
   EXPECT_NE(null, entry);
   entry->Close();
   entry = NULL;
 
   // Force the entry to flush to disk, so subsequent platform file operations
   // succed.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   entry->Close();
   entry = NULL;
 
   // Truncate the file such that the length isn't sufficient to have an EOF
   // record.
   int kTruncationBytes = -static_cast<int>(sizeof(disk_cache::SimpleFileEOF));
   const base::FilePath entry_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
   const int64_t invalid_size = disk_cache::simple_util::GetFileSizeFromDataSize(
       key.size(), kTruncationBytes);
   EXPECT_TRUE(TruncatePath(entry_path, invalid_size));
-  EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
+  EXPECT_THAT(OpenEntry(key, &entry), IsError(net::ERR_FAILED));
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) {
   // Test sequence:
   // Create, Write, Read, Close.
   SetCacheType(net::APP_CACHE);  // APP_CACHE doesn't use optimistic operations.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* const null_entry = NULL;
 
   disk_cache::Entry* entry = NULL;
-  EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
+  EXPECT_THAT(CreateEntry("my key", &entry), IsOk());
   ASSERT_NE(null_entry, entry);
   ScopedEntryPtr entry_closer(entry);
 
   const int kBufferSize = 10;
   scoped_refptr<net::IOBufferWithSize> write_buffer(
       new net::IOBufferWithSize(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
   EXPECT_EQ(
       write_buffer->size(),
       WriteData(entry, 1, 0, write_buffer.get(), write_buffer->size(), false));
@@ skipping 14 matching lines @@
 
   MessageLoopHelper helper;
   CallbackTest create_callback(&helper, false);
 
   int expected_callback_runs = 0;
   const int kBufferSize = 10;
   scoped_refptr<net::IOBufferWithSize> write_buffer(
       new net::IOBufferWithSize(kBufferSize));
 
   disk_cache::Entry* entry = NULL;
-  EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
+  EXPECT_THAT(CreateEntry("my key", &entry), IsOk());
   ASSERT_NE(null_entry, entry);
   ScopedEntryPtr entry_closer(entry);
 
   CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
   CallbackTest write_callback(&helper, false);
   int ret = entry->WriteData(
       1,
       0,
       write_buffer.get(),
       write_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
       false);
-  ASSERT_EQ(net::ERR_IO_PENDING, ret);
+  ASSERT_THAT(ret, IsError(net::ERR_IO_PENDING));
   helper.WaitUntilCacheIoFinished(++expected_callback_runs);
 }
 
 TEST_F(DiskCacheEntryTest,
        SimpleCacheNonOptimisticOperationsBasicsWithoutWaiting) {
   // Test sequence:
   // Create, Write, Read, Close.
   SetCacheType(net::APP_CACHE);  // APP_CACHE doesn't use optimistic operations.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* const null_entry = NULL;
   MessageLoopHelper helper;
 
   disk_cache::Entry* entry = NULL;
   // Note that |entry| is only set once CreateEntry() completed which is why we
   // have to wait (i.e. use the helper CreateEntry() function).
-  EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
+  EXPECT_THAT(CreateEntry("my key", &entry), IsOk());
   ASSERT_NE(null_entry, entry);
   ScopedEntryPtr entry_closer(entry);
 
   const int kBufferSize = 10;
   scoped_refptr<net::IOBufferWithSize> write_buffer(
       new net::IOBufferWithSize(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
   CallbackTest write_callback(&helper, false);
   int ret = entry->WriteData(
       1,
       0,
       write_buffer.get(),
       write_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
       false);
-  EXPECT_EQ(net::ERR_IO_PENDING, ret);
+  EXPECT_THAT(ret, IsError(net::ERR_IO_PENDING));
   int expected_callback_runs = 1;
 
   scoped_refptr<net::IOBufferWithSize> read_buffer(
       new net::IOBufferWithSize(kBufferSize));
   CallbackTest read_callback(&helper, false);
   ret = entry->ReadData(
       1,
       0,
       read_buffer.get(),
       read_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&read_callback)));
-  EXPECT_EQ(net::ERR_IO_PENDING, ret);
+  EXPECT_THAT(ret, IsError(net::ERR_IO_PENDING));
   ++expected_callback_runs;
 
   helper.WaitUntilCacheIoFinished(expected_callback_runs);
   ASSERT_EQ(read_buffer->size(), write_buffer->size());
   EXPECT_EQ(
       0,
       memcmp(read_buffer->data(), write_buffer->data(), read_buffer->size()));
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
@@ skipping 135 matching lines @@
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   entry->Close();
 
   net::TestCompletionCallback cb;
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry2, cb.callback()));
-  ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
+  ASSERT_THAT(cb.GetResult(net::ERR_IO_PENDING), IsOk());
   ScopedEntryPtr entry_closer(entry2);
 
   EXPECT_NE(null, entry2);
   EXPECT_EQ(entry, entry2);
 
   // Check that we are not leaking.
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
 }
 
@@ skipping 14 matching lines @@
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   entry->Close();
 
   // Lets do a Write so we block until both the Close and the Write
   // operation finishes. Write must fail since we are writing in a closed entry.
   EXPECT_EQ(
       net::ERR_IO_PENDING,
       entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
-  EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING));
+  EXPECT_THAT(cb.GetResult(net::ERR_IO_PENDING), IsError(net::ERR_FAILED));
 
   // Finish running the pending tasks so that we fully complete the close
   // operation and destroy the entry object.
   base::RunLoop().RunUntilIdle();
 
   // At this point the |entry| must have been destroyed, and called
   // RemoveSelfFromBackend().
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry2, cb.callback()));
-  ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
+  ASSERT_THAT(cb.GetResult(net::ERR_IO_PENDING), IsOk());
   EXPECT_NE(null, entry2);
 
   disk_cache::Entry* entry3 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry3, cb.callback()));
-  ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
+  ASSERT_THAT(cb.GetResult(net::ERR_IO_PENDING), IsOk());
   EXPECT_NE(null, entry3);
   EXPECT_EQ(entry2, entry3);
   entry3->Close();
 
   // The previous Close doesn't actually closes the entry since we opened it
   // twice, so the next Write operation must succeed and it must be able to
   // perform it optimistically, since there is no operation running on this
   // entry.
   EXPECT_EQ(kSize1,
             entry2->WriteData(
@@ skipping 129 matching lines @@
   net::TestCompletionCallback cb;
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
 
-  EXPECT_EQ(net::ERR_IO_PENDING, cache_->DoomEntry(key, cb.callback()));
-  EXPECT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
+  EXPECT_THAT(cache_->DoomEntry(key, cb.callback()),
+              IsError(net::ERR_IO_PENDING));
+  EXPECT_THAT(cb.GetResult(net::ERR_IO_PENDING), IsOk());
 
   EXPECT_EQ(
       kSize1,
       entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
 
   entry->Close();
 
   // Finish running the pending tasks so that we fully complete the close
   // operation and destroy the entry object.
   base::RunLoop().RunUntilIdle();
@@ skipping 27 matching lines @@
 
   net::TestCompletionCallback doom_callback;
   EXPECT_EQ(net::ERR_IO_PENDING,
             cache_->DoomEntry(key, doom_callback.callback()));
 
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::OK,
             create_callback.GetResult(
                 cache_->CreateEntry(key, &entry2, create_callback.callback())));
   ScopedEntryPtr entry2_closer(entry2);
-  EXPECT_EQ(net::OK, doom_callback.GetResult(net::ERR_IO_PENDING));
+  EXPECT_THAT(doom_callback.GetResult(net::ERR_IO_PENDING), IsOk());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomDoom) {
   // Test sequence:
   // Create, Doom, Create, Doom (1st entry), Open.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
 
   const char key[] = "the first key";
 
   disk_cache::Entry* entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+  ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
   ScopedEntryPtr entry1_closer(entry1);
   EXPECT_NE(null, entry1);
 
-  EXPECT_EQ(net::OK, DoomEntry(key));
+  EXPECT_THAT(DoomEntry(key), IsOk());
 
   disk_cache::Entry* entry2 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
+  ASSERT_THAT(CreateEntry(key, &entry2), IsOk());
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_NE(null, entry2);
 
   // Redundantly dooming entry1 should not delete entry2.
   disk_cache::SimpleEntryImpl* simple_entry1 =
       static_cast<disk_cache::SimpleEntryImpl*>(entry1);
   net::TestCompletionCallback cb;
   EXPECT_EQ(net::OK,
             cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
 
   disk_cache::Entry* entry3 = NULL;
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
+  ASSERT_THAT(OpenEntry(key, &entry3), IsOk());
   ScopedEntryPtr entry3_closer(entry3);
   EXPECT_NE(null, entry3);
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateDoom) {
   // Test sequence:
   // Create, Doom, Create, Doom.
   SetSimpleCacheMode();
   InitCache();
 
   disk_cache::Entry* null = NULL;
 
   const char key[] = "the first key";
 
   disk_cache::Entry* entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+  ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
   ScopedEntryPtr entry1_closer(entry1);
   EXPECT_NE(null, entry1);
 
   entry1->Doom();
 
   disk_cache::Entry* entry2 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
+  ASSERT_THAT(CreateEntry(key, &entry2), IsOk());
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_NE(null, entry2);
 
   entry2->Doom();
 
   // This test passes if it doesn't crash.
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCloseCreateCloseOpen) {
   // Test sequence: Create, Doom, Close, Create, Close, Open.
   SetSimpleCacheMode();
   InitCache();
 
   disk_cache::Entry* null = NULL;
 
   const char key[] = "this is a key";
 
   disk_cache::Entry* entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+  ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
   ScopedEntryPtr entry1_closer(entry1);
   EXPECT_NE(null, entry1);
 
   entry1->Doom();
   entry1_closer.reset();
   entry1 = NULL;
 
   disk_cache::Entry* entry2 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
+  ASSERT_THAT(CreateEntry(key, &entry2), IsOk());
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_NE(null, entry2);
 
   entry2_closer.reset();
   entry2 = NULL;
 
   disk_cache::Entry* entry3 = NULL;
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
+  ASSERT_THAT(OpenEntry(key, &entry3), IsOk());
   ScopedEntryPtr entry3_closer(entry3);
   EXPECT_NE(null, entry3);
 }
 
 // Checks that an optimistic Create would fail later on a racing Open.
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen) {
   SetSimpleCacheMode();
   InitCache();
 
   // Create a corrupt file in place of a future entry. Optimistic create should
   // initially succeed, but realize later that creation failed.
   const std::string key = "the key";
   net::TestCompletionCallback cb;
   disk_cache::Entry* entry = NULL;
   disk_cache::Entry* entry2 = NULL;
 
   EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
       key, cache_path_));
-  EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback()));
+  EXPECT_THAT(cache_->CreateEntry(key, &entry, cb.callback()), IsOk());
   ASSERT_TRUE(entry);
   ScopedEntryPtr entry_closer(entry);
   ASSERT_NE(net::OK, OpenEntry(key, &entry2));
 
   // Check that we are not leaking.
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 
   DisableIntegrityCheck();
 }
 
 // Tests that old entries are evicted while new entries remain in the index.
 // This test relies on non-mandatory properties of the simple Cache Backend:
 // LRU eviction, specific values of high-watermark and low-watermark etc.
 // When changing the eviction algorithm, the test will have to be re-engineered.
 TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) {
   const int kMaxSize = 200 * 1024;
   const int kWriteSize = kMaxSize / 10;
   const int kNumExtraEntries = 12;
   SetSimpleCacheMode();
   SetMaxSize(kMaxSize);
   InitCache();
 
   std::string key1("the first key");
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
+  ASSERT_THAT(CreateEntry(key1, &entry), IsOk());
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize));
   CacheTestFillBuffer(buffer->data(), kWriteSize, false);
   EXPECT_EQ(kWriteSize,
             WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
   entry->Close();
   AddDelay();
 
   std::string key2("the key prefix");
   for (int i = 0; i < kNumExtraEntries; i++) {
     if (i == kNumExtraEntries - 2) {
       // Create a distinct timestamp for the last two entries. These entries
       // will be checked for outliving the eviction.
       AddDelay();
     }
-    ASSERT_EQ(net::OK, CreateEntry(key2 + base::IntToString(i), &entry));
+    ASSERT_THAT(CreateEntry(key2 + base::IntToString(i), &entry), IsOk());
     ScopedEntryPtr entry_closer(entry);
     EXPECT_EQ(kWriteSize,
               WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
   }
 
   // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using
   // the internal knowledge about |SimpleBackendImpl|.
   ASSERT_NE(net::OK, OpenEntry(key1, &entry))
       << "Should have evicted the old entry";
   for (int i = 0; i < 2; i++) {
@@ skipping 14 matching lines @@
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
 
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   EXPECT_EQ(kBufferSize,
             WriteData(entry, 1, 0, write_buffer.get(), kBufferSize, false));
   entry->Close();
   entry = NULL;
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   ScopedEntryPtr entry_closer(entry);
 
   MessageLoopHelper helper;
   int expected = 0;
 
   // Make a short read.
   const int kReadBufferSize = 512;
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   CallbackTest read_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
@@ skipping 85 matching lines @@
 
   // Assume the index is not initialized, which is likely, since we are blocking
   // the IO thread from executing the index finalization step.
   disk_cache::Entry* entry1;
   net::TestCompletionCallback cb1;
   disk_cache::Entry* entry2;
   net::TestCompletionCallback cb2;
   int rv1 = cache_->OpenEntry("key", &entry1, cb1.callback());
   int rv2 = cache_->CreateEntry("key", &entry2, cb2.callback());
 
-  EXPECT_EQ(net::ERR_FAILED, cb1.GetResult(rv1));
-  ASSERT_EQ(net::OK, cb2.GetResult(rv2));
+  EXPECT_THAT(cb1.GetResult(rv1), IsError(net::ERR_FAILED));
+  ASSERT_THAT(cb2.GetResult(rv2), IsOk());
   entry2->Close();
 }
 
 // Checking one more scenario of overlapped reading of a bad entry.
 // Differs from the |SimpleCacheMultipleReadersCheckCRC| only by the order of
 // last two reads.
 TEST_F(DiskCacheEntryTest, SimpleCacheMultipleReadersCheckCRC2) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "key";
   int size;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size));
 
   scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size));
   scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size));
 
   // Advance the first reader a little.
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   ScopedEntryPtr entry_closer(entry);
   EXPECT_EQ(1, ReadData(entry, 1, 0, read_buffer1.get(), 1));
 
   // Advance the 2nd reader by the same amount.
   disk_cache::Entry* entry2 = NULL;
-  EXPECT_EQ(net::OK, OpenEntry(key, &entry2));
+  EXPECT_THAT(OpenEntry(key, &entry2), IsOk());
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_EQ(1, ReadData(entry2, 1, 0, read_buffer2.get(), 1));
 
   // Continue reading 1st.
   EXPECT_GT(0, ReadData(entry, 1, 1, read_buffer1.get(), size));
 
   // This read should fail as well because we have previous read failures.
   EXPECT_GT(0, ReadData(entry2, 1, 1, read_buffer2.get(), 1));
   DisableIntegrityCheck();
 }
 
 // Test if we can sequentially read each subset of the data until all the data
 // is read, then the CRC is calculated correctly and the reads are successful.
 TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) {
   // Test sequence:
   // Create, Write, Read (first half of data), Read (second half of data),
   // Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   const int kHalfSize = 200;
   const int kSize = 2 * kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   disk_cache::Entry* entry = NULL;
 
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_NE(null, entry);
 
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
   entry->Close();
 
   disk_cache::Entry* entry2 = NULL;
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
+  ASSERT_THAT(OpenEntry(key, &entry2), IsOk());
   EXPECT_EQ(entry, entry2);
 
   // Read the first half of the data.
   int offset = 0;
   int buf_len = kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(buf_len));
   EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read1.get(), buf_len));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), buf_len));
 
   // Read the second half of the data.
@@ skipping 25 matching lines @@
 
   const int kHalfSize = 200;
   const int kSize = 2 * kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   char* buffer1_data = buffer1->data() + kHalfSize;
   memcpy(buffer2->data(), buffer1_data, kHalfSize);
 
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Close();
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+    ASSERT_THAT(OpenEntry(key, &entry), IsOk());
     EXPECT_NE(null, entry);
 
     int offset = kHalfSize;
     int buf_len = kHalfSize;
 
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer2.get(), buf_len, false));
     offset = 0;
     buf_len = kHalfSize;
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer1.get(), buf_len, false));
     entry->Close();
 
-    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+    ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
     scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
     EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
     EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kSize));
     // Check that we are not leaking.
     ASSERT_NE(entry, null);
     EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
     entry->Close();
   }
 }
 
 // Test that changing stream1 size does not affect stream0 (stream0 and stream1
 // are stored in the same file in Simple Cache).
 TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges) {
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry = NULL;
   const std::string key("the key");
   const int kSize = 100;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer_read(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_TRUE(entry);
 
   // Write something into stream0.
   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
   entry->Close();
 
   // Extend stream1.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   int stream1_size = 100;
   EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, false));
   EXPECT_EQ(stream1_size, entry->GetDataSize(1));
   entry->Close();
 
   // Check that stream0 data has not been modified and that the EOF record for
   // stream 0 contains a crc.
   // The entry needs to be reopened before checking the crc: Open will perform
   // the synchronization with the previous Close. This ensures the EOF records
   // have been written to disk before we attempt to read them independently.
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   base::FilePath entry_file0_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
   base::File entry_file0(entry_file0_path,
                          base::File::FLAG_READ | base::File::FLAG_OPEN);
   ASSERT_TRUE(entry_file0.IsValid());
 
   int data_size[disk_cache::kSimpleEntryStreamCount] = {kSize, stream1_size, 0};
   int sparse_data_size = 0;
   disk_cache::SimpleEntryStat entry_stat(
       base::Time::Now(), base::Time::Now(), data_size, sparse_data_size);
@@ skipping 11 matching lines @@
   EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
 
   // Shrink stream1.
   stream1_size = 50;
   EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, true));
   EXPECT_EQ(stream1_size, entry->GetDataSize(1));
   entry->Close();
 
   // Check that stream0 data has not been modified.
   buffer_read = new net::IOBuffer(kSize);
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
   entry->Close();
   entry = NULL;
 }
 
 // Test that writing within the range for which the crc has already been
 // computed will properly invalidate the computed crc.
 TEST_F(DiskCacheEntryTest, SimpleCacheCRCRewrite) {
   // Test sequence:
   // Create, Write (big data), Write (small data in the middle), Close.
   // Open, Read (all), Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   const int kHalfSize = 200;
   const int kSize = 2 * kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kHalfSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   CacheTestFillBuffer(buffer2->data(), kHalfSize, false);
 
   disk_cache::Entry* entry = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_NE(null, entry);
   entry->Close();
 
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+    ASSERT_THAT(OpenEntry(key, &entry), IsOk());
     int offset = 0;
     int buf_len = kSize;
 
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer1.get(), buf_len, false));
     offset = kHalfSize;
     buf_len = kHalfSize;
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer2.get(), buf_len, false));
     entry->Close();
 
-    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+    ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
     scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
     EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
     EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kHalfSize));
     EXPECT_EQ(
         0,
         memcmp(buffer2->data(), buffer1_read1->data() + kHalfSize, kHalfSize));
 
     entry->Close();
   }
@@ skipping 19 matching lines @@
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream1) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "key";
 
   disk_cache::Entry* entry;
 
   // Create entry and close without writing: third stream file should be
   // omitted, since the stream is empty.
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that a newly-created entry with only a single zero-offset, zero-length
 // write omits the third stream file.
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream2) {
   SetSimpleCacheMode();
   InitCache();
 
   const int kHalfSize = 8;
   const int kSize = kHalfSize * 2;
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write empty buffer to third stream, and close: third stream
   // should still be omitted, since the entry ignores writes that don't modify
   // data or change the length.
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_EQ(0, WriteData(entry, 2, 0, buffer.get(), 0, true));
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we can read back data written to the third stream.
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3) {
   SetSimpleCacheMode();
   InitCache();
 
   const int kHalfSize = 8;
   const int kSize = kHalfSize * 2;
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write data to third stream, and close: third stream should
   // not be omitted, since it contains data.  Re-open entry and ensure there
   // are that many bytes in the third stream.
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_EQ(kHalfSize, ReadData(entry, 2, 0, buffer2.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kHalfSize));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we remove the third stream file upon opening an entry and finding
@@ skipping 10 matching lines @@
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write data to third stream, truncate third stream back to
   // empty, and close: third stream will not initially be omitted, since entry
   // creates the file when the first significant write comes in, and only
   // removes it on open if it is empty.  Reopen, ensure that the file is
   // deleted, and that there's no data in the third stream.
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
   EXPECT_EQ(0, WriteData(entry, 2, 0, buffer1.get(), 0, true));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
   EXPECT_EQ(0, ReadData(entry, 2, 0, buffer2.get(), kSize));
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we don't accidentally create the third stream file once the entry
 // has been doomed.
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5) {
   SetSimpleCacheMode();
   InitCache();
 
   const int kHalfSize = 8;
   const int kSize = kHalfSize * 2;
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, doom entry, write data to third stream, and close: third
   // stream should not exist.  (Note: We don't care if the write fails, just
   // that it doesn't cause the file to be created on disk.)
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Doom();
   WriteData(entry, 2, 0, buffer.get(), kHalfSize, true);
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // There could be a race between Doom and an optimistic write.
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomOptimisticWritesRace) {
   // Test sequence:
   // Create, first Write, second Write, Close.
   // Open, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   const int kSize = 200;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   CacheTestFillBuffer(buffer2->data(), kSize, false);
 
   // The race only happens on stream 1 and stream 2.
   for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
-    ASSERT_EQ(net::OK, DoomAllEntries());
+    ASSERT_THAT(DoomAllEntries(), IsOk());
     disk_cache::Entry* entry = NULL;
 
-    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+    ASSERT_THAT(CreateEntry(key, &entry), IsOk());
     EXPECT_NE(null, entry);
     entry->Close();
     entry = NULL;
 
-    ASSERT_EQ(net::OK, DoomAllEntries());
-    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+    ASSERT_THAT(DoomAllEntries(), IsOk());
+    ASSERT_THAT(CreateEntry(key, &entry), IsOk());
     EXPECT_NE(null, entry);
 
     int offset = 0;
     int buf_len = kSize;
     // This write should not be optimistic (since create is).
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer1.get(), buf_len, false));
 
     offset = kSize;
     // This write should be optimistic.
     EXPECT_EQ(buf_len,
               WriteData(entry, i, offset, buffer2.get(), buf_len, false));
     entry->Close();
 
-    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+    ASSERT_THAT(OpenEntry(key, &entry), IsOk());
     EXPECT_NE(null, entry);
 
     entry->Close();
     entry = NULL;
   }
 }
 
 // Tests for a regression in crbug.com/317138 , in which deleting an already
 // doomed entry was removing the active entry from the index.
 TEST_F(DiskCacheEntryTest, SimpleCachePreserveActiveEntries) {
   SetSimpleCacheMode();
   InitCache();
 
   disk_cache::Entry* null = NULL;
 
   const char key[] = "this is a key";
 
   disk_cache::Entry* entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+  ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
   ScopedEntryPtr entry1_closer(entry1);
   EXPECT_NE(null, entry1);
   entry1->Doom();
 
   disk_cache::Entry* entry2 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
+  ASSERT_THAT(CreateEntry(key, &entry2), IsOk());
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_NE(null, entry2);
   entry2_closer.reset();
 
   // Closing then reopening entry2 insures that entry2 is serialized, and so
   // it can be opened from files without error.
   entry2 = NULL;
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
+  ASSERT_THAT(OpenEntry(key, &entry2), IsOk());
   EXPECT_NE(null, entry2);
   entry2_closer.reset(entry2);
 
   scoped_refptr<disk_cache::SimpleEntryImpl>
       entry1_refptr = static_cast<disk_cache::SimpleEntryImpl*>(entry1);
 
   // If crbug.com/317138 has regressed, this will remove |entry2| from
   // the backend's |active_entries_| while |entry2| is still alive and its
   // files are still on disk.
   entry1_closer.reset();
   entry1 = NULL;
 
   // Close does not have a callback. However, we need to be sure the close is
   // finished before we continue the test. We can take advantage of how the ref
   // counting of a SimpleEntryImpl works to fake out a callback: When the
   // last Close() call is made to an entry, an IO operation is sent to the
   // synchronous entry to close the platform files. This IO operation holds a
   // ref pointer to the entry, which expires when the operation is done. So,
   // we take a refpointer, and watch the SimpleEntry object until it has only
   // one ref; this indicates the IO operation is complete.
   while (!entry1_refptr->HasOneRef()) {
     base::PlatformThread::YieldCurrentThread();
     base::RunLoop().RunUntilIdle();
   }
   entry1_refptr = NULL;
 
   // In the bug case, this new entry ends up being a duplicate object pointing
   // at the same underlying files.
   disk_cache::Entry* entry3 = NULL;
-  EXPECT_EQ(net::OK, OpenEntry(key, &entry3));
+  EXPECT_THAT(OpenEntry(key, &entry3), IsOk());
   ScopedEntryPtr entry3_closer(entry3);
   EXPECT_NE(null, entry3);
 
   // The test passes if these two dooms do not crash.
   entry2->Doom();
   entry3->Doom();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheBasicSparseIO) {
   SetSimpleCacheMode();
@@ skipping 36 matching lines @@
 
   SetSimpleCacheMode();
   // An entry is allowed sparse data 1/10 the size of the cache, so this size
   // allows for one |kSize|-sized range plus overhead, but not two ranges.
   SetMaxSize(kSize * 15);
   InitCache();
 
   const char key[] = "key";
   disk_cache::Entry* null = NULL;
   disk_cache::Entry* entry;
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   EXPECT_NE(null, entry);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   net::TestCompletionCallback callback;
   int ret;
 
   // Verify initial conditions.
   ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
@@ skipping 15 matching lines @@
   ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   // Make sure the first range was removed when the second was written.
   ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   // Close and reopen the entry and make sure the first entry is still absent
   // and the second entry is still present.
   entry->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
 
   ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReadWithoutKeySHA256) {
   // This test runs as APP_CACHE to make operations more synchronous.
   SetCacheType(net::APP_CACHE);
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry;
   std::string key("a key");
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
 
   const std::string stream_0_data = "data for stream zero";
   scoped_refptr<net::IOBuffer> stream_0_iobuffer(
       new net::StringIOBuffer(stream_0_data));
   EXPECT_EQ(static_cast<int>(stream_0_data.size()),
             WriteData(entry, 0, 0, stream_0_iobuffer.get(),
                       stream_0_data.size(), false));
   const std::string stream_1_data = "FOR STREAM ONE, QUITE DIFFERENT THINGS";
   scoped_refptr<net::IOBuffer> stream_1_iobuffer(
       new net::StringIOBuffer(stream_1_data));
   EXPECT_EQ(static_cast<int>(stream_1_data.size()),
             WriteData(entry, 1, 0, stream_1_iobuffer.get(),
                       stream_1_data.size(), false));
   entry->Close();
 
   base::RunLoop().RunUntilIdle();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(
       disk_cache::simple_util::RemoveKeySHA256FromEntry(key, cache_path_));
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   ScopedEntryPtr entry_closer(entry);
 
   EXPECT_EQ(static_cast<int>(stream_0_data.size()), entry->GetDataSize(0));
   scoped_refptr<net::IOBuffer> check_stream_0_data(
       new net::IOBuffer(stream_0_data.size()));
   EXPECT_EQ(
       static_cast<int>(stream_0_data.size()),
       ReadData(entry, 0, 0, check_stream_0_data.get(), stream_0_data.size()));
   EXPECT_EQ(0, stream_0_data.compare(0, std::string::npos,
                                      check_stream_0_data->data(),
@@ skipping 10 matching lines @@
                                      stream_1_data.size()));
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoubleOpenWithoutKeySHA256) {
   // This test runs as APP_CACHE to make operations more synchronous.
   SetCacheType(net::APP_CACHE);
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry;
   std::string key("a key");
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Close();
 
   base::RunLoop().RunUntilIdle();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(
       disk_cache::simple_util::RemoveKeySHA256FromEntry(key, cache_path_));
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   entry->Close();
 
   base::RunLoop().RunUntilIdle();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
-  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_THAT(OpenEntry(key, &entry), IsOk());
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheReadCorruptKeySHA256) {
   // This test runs as APP_CACHE to make operations more synchronous.
   SetCacheType(net::APP_CACHE);
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry;
   std::string key("a key");
-  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  ASSERT_THAT(CreateEntry(key, &entry), IsOk());
   entry->Close();
 
   base::RunLoop().RunUntilIdle();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(
       disk_cache::simple_util::CorruptKeySHA256FromEntry(key, cache_path_));
   EXPECT_NE(net::OK, OpenEntry(key, &entry));
 }