Remove MessageLoop::current()->RunUntilIdle() in net.

net/http/http_cache_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 "net/http/http_cache.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 1270 matching lines @@
         c->trans->Start(&request, c->callback.callback(), BoundNetLog());
   }
 
   // All requests are waiting for the active entry.
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, c->trans->GetLoadState());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // All requests depend on the writer, and the writer is between Start and
   // Read, i.e. idle.
@@ skipping 44 matching lines @@
 
     MockHttpRequest* this_request = &request;
     if (i == 1 || i == 2)
       this_request = &reader_request;
 
     c->result =
         c->trans->Start(this_request, c->callback.callback(), BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   Context* c = context_list[0];
   ASSERT_EQ(ERR_IO_PENDING, c->result);
@@ skipping 106 matching lines @@
     Context* c = context_list[i];
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_EQ(OK, c->result);
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Now, make sure that the second request asks for the entry not to be stored.
   request_handler.set_no_store(true);
@@ skipping 26 matching lines @@
     Context* c = context_list[i];
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_EQ(OK, c->result);
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
@@ skipping 93 matching lines @@
   ASSERT_EQ(OK, c->result);
 
   c->result = c->trans->Start(&request, c->callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, c->result);
 
   // Release the reference that the mock disk cache keeps for this entry, so
   // that we test that the http cache handles the cancellation correctly.
   cache.disk_cache()->ReleaseAll();
   delete c;
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete/create entries even if multiple requests are queued.
 TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   request.load_flags = LOAD_BYPASS_CACHE;
 
@@ skipping 80 matching lines @@
   scoped_refptr<IOBuffer> buf(new IOBuffer(256));
   rv = trans->Read(buf.get(), 256, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
   // works properly.
   trans.reset();
 
   // Make sure we pump any pending events, which should include a call to
   // HttpCache::Transaction::OnCacheReadCompleted.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Tests that we can delete the HttpCache and deal with queued transactions
 // ("waiting for the backend" as opposed to Active or Doomed entries).
 TEST(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
   std::unique_ptr<MockHttpCache> cache(
       new MockHttpCache(base::WrapUnique(new MockBackendNoCbFactory())));
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
@@ skipping 48 matching lines @@
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), BoundNetLog());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), BoundNetLog());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), BoundNetLog());
 
   // Just to make sure that everything is still pending.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be creating the disk cache.
   EXPECT_FALSE(context_list[0]->callback.have_result());
 
   factory->FinishCreation();
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(3, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     EXPECT_TRUE(context_list[i]->callback.have_result());
     delete context_list[i];
   }
 }
 
 // Tests that we can cancel requests that are queued waiting for the backend
@@ skipping 18 matching lines @@
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), BoundNetLog());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), BoundNetLog());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), BoundNetLog());
 
   // Just to make sure that everything is still pending.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The first request should be creating the disk cache.
   EXPECT_FALSE(context_list[0]->callback.have_result());
 
   // Cancel a request from the pending queue.
   delete context_list[1];
   context_list[1] = NULL;
 
   // Cancel the request that is creating the entry.
   delete context_list[0];
@@ skipping 20 matching lines @@
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::unique_ptr<Context> c(new Context());
   c->result = cache->CreateTransaction(&c->trans);
   ASSERT_EQ(OK, c->result);
 
   c->trans->Start(&request, c->callback.callback(), BoundNetLog());
 
   // Just to make sure that everything is still pending.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The request should be creating the disk cache.
   EXPECT_FALSE(c->callback.have_result());
 
   // We cannot call FinishCreation because the factory itself will go away with
   // the cache, so grab the callback and attempt to use it.
   CompletionCallback callback = factory->callback();
   std::unique_ptr<disk_cache::Backend>* backend = factory->backend();
 
   cache.reset();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   backend->reset();
   callback.Run(ERR_ABORTED);
 }
 
 // Tests that we can delete the cache while creating the backend, from within
 // one of the callbacks.
 TEST(HttpCache, DeleteCacheWaitingForBackend2) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   MockHttpCache* cache = new MockHttpCache(base::WrapUnique(factory));
@@ skipping 11 matching lines @@
   ASSERT_EQ(OK, c->result);
 
   c->trans->Start(&request, c->callback.callback(), BoundNetLog());
 
   // And another direct backend request.
   TestCompletionCallback cb2;
   rv = cache->http_cache()->GetBackend(&backend, cb2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Just to make sure that everything is still pending.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The request should be queued.
   EXPECT_FALSE(c->callback.have_result());
 
   // Generate the callback.
   factory->FinishCreation();
   rv = cb.WaitForResult();
 
   // The cache should be gone by now.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(OK, c->callback.GetResult(c->result));
   EXPECT_FALSE(cb2.have_result());
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_TypicalGET_ConditionalRequest \
   DISABLED_TypicalGET_ConditionalRequest
 #else
 #define MAYBE_TypicalGET_ConditionalRequest TypicalGET_ConditionalRequest
@@ skipping 1383 matching lines @@
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
   RemoveMockTransaction(&transaction);
 
   EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   MockTransaction transaction2(kTypicalGET_Transaction);
   AddMockTransaction(&transaction2);
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Load from the cache.
   transaction2.load_flags |= LOAD_ONLY_FROM_CACHE;
   RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
 
   EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction2);
@@ skipping 19 matching lines @@
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
   RemoveMockTransaction(&transaction);
 
   EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 304 Not Modified\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   MockTransaction transaction2(kTypicalGET_Transaction);
   AddMockTransaction(&transaction2);
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Load from the cache.
   transaction2.load_flags |= LOAD_ONLY_FROM_CACHE;
   RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
 
   EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction2);
@@ skipping 673 matching lines @@
   // Read from the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write to the cache (30-39).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
   transaction.data = "rg: 30-39 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 30, 39);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write and read from the cache (20-59).
   transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
   transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
   RunTransactionTestWithResponseAndGetTiming(
       cache.http_cache(), transaction, &headers, log.bound(),
       &load_timing_info);
 
@@ skipping 32 matching lines @@
 
   // Read from the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write to the cache (30-39).
   transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
   transaction.data = "rg: 30-39 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 30, 39);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write and read from the cache (20-59).
   transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
   transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
   RunTransactionTestWithResponseAndGetTiming(
       cache.http_cache(), transaction, &headers, log.bound(),
       &load_timing_info);
 
@@ skipping 466 matching lines @@
   transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 70, 79);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write and read from the cache (60-79).
   transaction.request_headers = "Range: bytes = 60-\r\n" EXTRA_HEADER;
   transaction.data = "rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 60, 79);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 18 matching lines @@
   transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 70, 79);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Write and read from the cache (60-79).
   transaction.request_headers = "Range: bytes = -20\r\n" EXTRA_HEADER;
   transaction.data = "rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 60, 79);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 325 matching lines @@
   handler.set_not_modified(true);
   RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
 
   // We are expecting a 206.
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // The last transaction has finished so make sure the entry is deactivated.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Make a request for an invalid range.
   MockTransaction transaction3(kRangeGET_TransactionOK);
   transaction3.request_headers = "Range: bytes = 80-90\r\n" EXTRA_HEADER;
   transaction3.data = transaction.data;
   transaction3.load_flags = LOAD_PREFERRING_CACHE;
   RunTransactionTestWithResponse(cache.http_cache(), transaction3, &headers);
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(0U, headers.find("HTTP/1.1 200 "));
   EXPECT_EQ(std::string::npos, headers.find("Content-Range:"));
   EXPECT_EQ(std::string::npos, headers.find("Content-Length: 80"));
 
   // Make sure the entry is deactivated.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Even though the request was invalid, we should have the entry.
   RunTransactionTest(cache.http_cache(), transaction2);
   EXPECT_EQ(3, cache.disk_cache()->open_count());
 
   // Make sure the entry is deactivated.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Now we should receive a range from the server and drop the stored entry.
   handler.set_not_modified(false);
   transaction2.request_headers = kRangeGET_TransactionOK.request_headers;
   RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(4, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
@@ skipping 207 matching lines @@
   // active entry (no open or create).
 
   c = new Context();
   rv = cache.CreateTransaction(&c->trans);
   ASSERT_EQ(OK, rv);
 
   rv = c->trans->Start(&request, c->callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   MockDiskEntry::IgnoreCallbacks(true);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   MockDiskEntry::IgnoreCallbacks(false);
 
   // The new transaction is waiting for the query range callback.
   delete c;
 
   // And we should not crash when the callback is delivered.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that an invalid range response results in no cached entry.
 TEST(HttpCache, RangeGET_InvalidResponse1) {
   MockHttpCache cache;
@@ skipping 691 matching lines @@
   EXPECT_EQ(5, c->callback.GetResult(rv));
 
   // Cancel the requests.
   delete c;
   delete pending;
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we delete truncated entries if the server changes its mind midway.
 TEST(HttpCache, GET_IncompleteResource2) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Content-length will be intentionally bad.
   std::string raw_headers("HTTP/1.1 200 OK\n"
@@ skipping 335 matching lines @@
     // Destroy transaction when going out of scope. We have not actually
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Active entries in the cache are not retired synchronously. Make
   // sure the next run hits the MockHttpCache and open_count is
   // correct.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read from the cache.
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_EQ(OK, cache.CreateTransaction(&trans));
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(OK, rv);
@@ skipping 304 matching lines @@
   memset(buf->data(), 0, buf->size());
   base::strlcpy(buf->data(), "Hi there", buf->size());
   cache.http_cache()->WriteMetadata(GURL(kSimpleGET_Transaction.url),
                                     DEFAULT_PRIORITY, response.response_time,
                                     buf.get(), buf->size());
 
   // Release the buffer before the operation takes place.
   buf = NULL;
 
   // Makes sure we finish pending operations.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response);
   ASSERT_TRUE(response.metadata.get() != NULL);
   EXPECT_EQ(50, response.metadata->size());
   EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 13 matching lines @@
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(50));
   memset(buf->data(), 0, buf->size());
   base::strlcpy(buf->data(), "Hi there", buf->size());
   base::Time expected_time = response.response_time -
                              base::TimeDelta::FromMilliseconds(20);
   cache.http_cache()->WriteMetadata(GURL(kSimpleGET_Transaction.url),
                                     DEFAULT_PRIORITY, expected_time, buf.get(),
                                     buf->size());
 
   // Makes sure we finish pending operations.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
@@ skipping 10 matching lines @@
 
   // Write meta data to the same entry.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(50));
   memset(buf->data(), 0, buf->size());
   base::strlcpy(buf->data(), "Hi there", buf->size());
   cache.http_cache()->WriteMetadata(GURL(kTypicalGET_Transaction.url),
                                     DEFAULT_PRIORITY, response.response_time,
                                     buf.get(), buf->size());
 
   // Makes sure we finish pending operations.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Start with a READ mode transaction.
   MockTransaction trans1(kTypicalGET_Transaction);
   trans1.load_flags = LOAD_ONLY_FROM_CACHE;
 
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans1, &response);
   ASSERT_TRUE(response.metadata.get() != NULL);
   EXPECT_EQ(50, response.metadata->size());
   EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Now make sure that the entry is re-validated with the server.
   trans1.load_flags = LOAD_VALIDATE_CACHE;
   trans1.status = "HTTP/1.1 304 Not Modified";
   AddMockTransaction(&trans1);
 
   response.metadata = NULL;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans1, &response);
   EXPECT_TRUE(response.metadata.get() != NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(3, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   RemoveMockTransaction(&trans1);
 
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
@@ skipping 16 matching lines @@
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
 
     // Now make sure that the entry is preserved.
     trans->DoneReading();
   }
 
   // Make sure that the ActiveEntry is gone.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read from the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we don't mark entries as truncated and release the cache
@@ skipping 10 matching lines @@
   ASSERT_EQ(OK, cache.CreateTransaction(&trans));
 
   MockHttpRequest request(transaction);
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(OK, callback.GetResult(rv));
 
   trans->DoneReading();
   // Leave the transaction around.
 
   // Make sure that the ActiveEntry is gone.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read from the cache. This should not deadlock.
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told.
@@ skipping 16 matching lines @@
     trans->StopCaching();
 
     // We should be able to keep reading.
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(0, callback.GetResult(rv));
   }
 
   // Make sure that the ActiveEntry is gone.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told, even if DoneReading is called
@@ skipping 20 matching lines @@
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(0, callback.GetResult(rv));
 
     // We should be able to call DoneReading.
     trans->DoneReading();
   }
 
   // Make sure that the ActiveEntry is gone.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told, when using auth.
@@ skipping 14 matching lines @@
 
     trans->StopCaching();
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
     rv = trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
   }
   RemoveMockTransaction(&mock_transaction);
 
   // Make sure that the ActiveEntry is gone.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that when we are told to stop caching we don't throw away valid data.
@@ skipping 301 matching lines @@
   // Read bytes 40-49 from the network.
   int64_t sent, received;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   // Read bytes 40-49 from the cache.
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(0, sent);
   EXPECT_EQ(0, received);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read bytes 30-39 from the network.
   transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
   transaction.data = "rg: 30-39 ";
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read bytes 20-29 and 50-59 from the network, bytes 30-49 from the cache.
   transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
   transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes * 2, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes * 2, received);
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
@@ skipping 293 matching lines @@
   MockHttpRequest request(mock_transaction);
 
   std::unique_ptr<Context> first(new Context);
   first->result = cache.CreateTransaction(&first->trans);
   ASSERT_EQ(OK, first->result);
   EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
   first->result =
       first->trans->Start(&request, first->callback.callback(), BoundNetLog());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, first->trans->GetLoadState());
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
   ASSERT_TRUE(first->trans->GetResponseInfo());
   EXPECT_TRUE(first->trans->GetResponseInfo()->headers->HasHeaderValue(
       "Cache-Control", "no-store"));
   // Here we have read the response header but not read the response body yet.
 
   // Let us create the second (read) transaction.
   std::unique_ptr<Context> second(new Context);
   second->result = cache.CreateTransaction(&second->trans);
   ASSERT_EQ(OK, second->result);
   EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
   second->result = second->trans->Start(&request, second->callback.callback(),
                                         BoundNetLog());
 
   // Here the second transaction proceeds without reading the first body.
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
   ASSERT_TRUE(second->trans->GetResponseInfo());
   EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
       "Cache-Control", "no-store"));
   ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
 }
 
 // Tests that serving a response entirely from cache replays the previous
 // SSLInfo.
 TEST(HttpCache, CachePreservesSSLInfo) {
@@ skipping 96 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   EXPECT_TRUE(response_info.was_cached);
 
   // The new SSL state is reported.
   EXPECT_EQ(status2, response_info.ssl_info.connection_status);
   EXPECT_TRUE(cert2->Equals(response_info.ssl_info.cert.get()));
 }
 
 }  // namespace net