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

mojo/shell/application_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 36 matching lines @@
  public:
   TestServiceImpl(TestContext* context, InterfaceRequest<TestService> request)
       : context_(context), binding_(this, request.Pass()) {
     ++context_->num_impls;
   }
 
   ~TestServiceImpl() override {
     --context_->num_impls;
     if (!base::MessageLoop::current()->is_running())
       return;
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   // TestService implementation:
   void Test(const String& test_string,
             const Callback<void()>& callback) override {
     context_->last_test_string = test_string;
     callback.Run();
   }
 
  private:
   TestContext* context_;
   StrongBinding<TestService> binding_;
 };
 
 class TestClient {
  public:
   explicit TestClient(TestServicePtr service)
       : service_(service.Pass()), quit_after_ack_(false) {}
 
   void AckTest() {
     if (quit_after_ack_)
-      base::MessageLoop::current()->Quit();
+      base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void Test(const std::string& test_string) {
     quit_after_ack_ = true;
     service_->Test(test_string,
                    base::Bind(&TestClient::AckTest, base::Unretained(this)));
   }
 
  private:
   TestServicePtr service_;
@@ skipping 171 matching lines @@
  private:
   void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void CallCFromB() override {
     b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void Quit() {
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
   scoped_ptr<ApplicationConnection> connection_;
   TesterContext* test_context_;
   TestBPtr b_;
   StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
   TestBImpl(ApplicationConnection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestB> request)
       : test_context_(test_context), binding_(this, request.Pass()) {
     connection->ConnectToService(&c_);
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
-      base::MessageLoop::current()->Quit();
+      base::MessageLoop::current()->QuitWhenIdle();
     test_context_->QuitSoon();
   }
 
  private:
   void B(const Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
   void CallC(const Callback<void()>& callback) override {
@@ skipping 39 matching lines @@
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
     app_.reset(new ApplicationImpl(this, application_request.Pass()));
   }
 
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     if (!requestor_url_.empty() &&
         requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
-      base::MessageLoop::current()->Quit();
+      base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
@@ skipping 259 matching lines @@
 
   // A different identity because the domain is different.
   ConnectToService(application_manager_.get(),
                    GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo