base: Update the calls from MessageLoop::Quit() to QuitWhenIdle().

base/message_pump_glib_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 "base/message_pump_glib.h"
 
 #include <glib.h>
 #include <math.h>
 
 #include <algorithm>
@@ skipping 293 matching lines @@
       : injector_(injector),
         event_count_(kStartingEventCount),
         task_count_(kStartingTaskCount) {
   }
 
   void FromTask() {
     if (task_count_ > 0) {
       --task_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
-        MessageLoop::current()->Quit();
+        MessageLoop::current()->QuitWhenIdle();
     } else {
       MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, this));
     }
   }
 
   void FromEvent() {
     if (event_count_ > 0) {
       --event_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
-        MessageLoop::current()->Quit();
+        MessageLoop::current()->QuitWhenIdle();
     } else {
       injector_->AddEventAsTask(
           0, base::Bind(&ConcurrentHelper::FromEvent, this));
     }
   }
 
   int event_count() const { return event_count_; }
   int task_count() const { return task_count_; }
 
  private:
   friend class base::RefCounted<ConcurrentHelper>;
 
   ~ConcurrentHelper() {}
 
   static const int kStartingEventCount = 20;
   static const int kStartingTaskCount = 20;
 
   EventInjector* injector_;
   int event_count_;
   int task_count_;
 };
 
 }  // namespace
 
 TEST_F(MessagePumpGLibTest, TestConcurrentEventPostedTask) {
   // Tests that posted tasks don't starve events, nor the opposite.
   // We use the helper class above. We keep both event and posted task queues
   // full, the helper verifies that both tasks and events get processed.
   // If that is not the case, either event_count_ or task_count_ will not get
-  // to 0, and MessageLoop::Quit() will never be called.
+  // to 0, and MessageLoop::QuitWhenIdle() will never be called.
   scoped_refptr<ConcurrentHelper> helper = new ConcurrentHelper(injector());
 
   // Add 2 events to the queue to make sure it is always full (when we remove
   // the event before processing it).
   injector()->AddEventAsTask(
       0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
   injector()->AddEventAsTask(
       0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
 
   // Similarly post 2 tasks.
@@ skipping 140 matching lines @@
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GLibLoopRunner::Quit, runner.get()),
       base::TimeDelta::FromMilliseconds(40));
 
   // Run a nested, straight GLib message loop.
   runner->RunGLib();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
-  MessageLoop::current()->Quit();
+  MessageLoop::current()->QuitWhenIdle();
 }
 
 void TestGtkLoopInternal(EventInjector* injector) {
   // Allow tasks to be processed from 'native' event loops.
   MessageLoop::current()->SetNestableTasksAllowed(true);
   scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
 
   int task_count = 0;
   // Add a couple of dummy events
   injector->AddDummyEvent(0);
@@ skipping 14 matching lines @@
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GLibLoopRunner::Quit, runner.get()),
       base::TimeDelta::FromMilliseconds(40));
 
   // Run a nested, straight Gtk message loop.
   runner->RunLoop();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
-  MessageLoop::current()->Quit();
+  MessageLoop::current()->QuitWhenIdle();
 }
 
 }  // namespace
 
 TEST_F(MessagePumpGLibTest, TestGLibLoop) {
   // Tests that events and posted tasks are correctly executed if the message
   // loop is not run by MessageLoop::Run() but by a straight GLib loop.
   // Note that in this case we don't make strong guarantees about niceness
   // between events and posted tasks.
   loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestGLibLoopInternal, base::Unretained(injector())));
   loop()->Run();
 }
 
 TEST_F(MessagePumpGLibTest, TestGtkLoop) {
   // Tests that events and posted tasks are correctly executed if the message
   // loop is not run by MessageLoop::Run() but by a straight Gtk loop.
   // Note that in this case we don't make strong guarantees about niceness
   // between events and posted tasks.
   loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestGtkLoopInternal, base::Unretained(injector())));
   loop()->Run();
 }