Don't use base::MessageLoop::{Quit,QuitClosure} in net/

net/dns/host_resolver_impl_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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 252 matching lines @@
   }
 
   bool HasOneAddress(const std::string& address, uint16 port) const {
     return HasAddress(address, port) && (NumberOfAddresses() == 1u);
   }
 
   // Returns ERR_UNEXPECTED if timed out.
   int WaitForResult() {
     if (completed())
       return result_;
-    base::CancelableClosure closure(base::MessageLoop::QuitClosure());
+    base::CancelableClosure closure(base::MessageLoop::QuitWhenIdleClosure());
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, closure.callback(), TestTimeouts::action_max_timeout());
     quit_on_complete_ = true;
     base::MessageLoop::current()->Run();
     bool did_quit = !quit_on_complete_;
     quit_on_complete_ = false;
     closure.Cancel();
     if (did_quit)
       return result_;
     else
       return ERR_UNEXPECTED;
   }
 
  private:
   void OnComplete(int rv) {
     EXPECT_TRUE(pending());
     EXPECT_EQ(ERR_IO_PENDING, result_);
     EXPECT_NE(ERR_IO_PENDING, rv);
     result_ = rv;
     handle_ = NULL;
     if (!list_.empty()) {
       EXPECT_EQ(OK, result_);
       EXPECT_EQ(info_.port(), list_.front().port());
     }
     if (handler_)
       handler_->Handle(this);
     if (quit_on_complete_) {
-      base::MessageLoop::current()->Quit();
+      base::MessageLoop::current()->QuitWhenIdle();
       quit_on_complete_ = false;
     }
   }
 
   HostResolver::RequestInfo info_;
   RequestPriority priority_;
   size_t index_;
   HostResolver* resolver_;
   Handler* handler_;
   bool quit_on_complete_;
@@ skipping 528 matching lines @@
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
       DeleteResolver();
 
       // Quit after returning from OnCompleted (to give it a chance at
       // incorrectly running the cancelled tasks).
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::MessageLoop::QuitClosure());
+          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     }
   };
   set_handler(new MyHandler());
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(1u);  // One for "a".
 
   // |MyHandler| will send quit message once all the requests have finished.
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
       DeleteResolver();
 
       // Quit after returning from OnCompleted (to give it a chance at
       // incorrectly running the cancelled tasks).
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::MessageLoop::QuitClosure());
+          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     }
   };
   set_handler(new MyHandler());
 
   // This test assumes that the Jobs will be Aborted in order ["a", "b"]
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
   // HostResolverImpl will be deleted before later Requests can complete.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 81)->Resolve());
   // Job for 'b' will be aborted before it can complete.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 82)->Resolve());
@@ skipping 57 matching lines @@
         EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache());
 
         // Ok good. Now make sure that if we ask to bypass the cache, it can no
         // longer service the request synchronously.
         HostResolver::RequestInfo info(HostPortPair(hostname, 71));
         info.set_allow_cached_response(false);
         EXPECT_EQ(ERR_IO_PENDING,
                   CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
       } else if (71 == req->info().port()) {
         // Test is done.
-        base::MessageLoop::current()->Quit();
+        base::MessageLoop::current()->QuitWhenIdle();
       } else {
         FAIL() << "Unexpected request";
       }
     }
   };
   set_handler(new MyHandler());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
   proc_->SignalMultiple(3u);  // Only need two, but be generous.
 
@@ skipping 1204 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 }  // namespace net