Removing MessageLoop::QuitTask() from content/

content/common/net/url_fetcher_impl_unittest.cc

 // Copyright (c) 2011 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 "content/common/net/url_fetcher_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
@@ skipping 106 matching lines @@
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
 
   delete fetcher_;  // Have to delete this here and not in the destructor,
                     // because the destructor won't necessarily run on the
                     // same thread that CreateFetcher() did.
 
-  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   // If the current message loop is not the IO loop, it will be shut down when
   // the main loop returns and this thread subsequently goes out of scope.
 }
 
 namespace {
 
 // Version of URLFetcherTest that does a POST instead
 class URLFetcherPostTest : public URLFetcherTest {
  public:
   virtual void CreateFetcher(const GURL& url);
@@ skipping 61 matching lines @@
 
   void CancelRequest();
 };
 
 // Version of TestURLRequestContext that posts a Quit task to the IO
 // thread once it is deleted.
 class CancelTestURLRequestContext : public TestURLRequestContext {
   virtual ~CancelTestURLRequestContext() {
     // The d'tor should execute in the IO thread. Post the quit task to the
     // current thread.
-    MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 };
 
 class CancelTestURLRequestContextGetter : public net::URLRequestContextGetter {
  public:
   explicit CancelTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy)
       : io_message_loop_proxy_(io_message_loop_proxy),
         context_created_(false, false) {
   }
@@ skipping 170 matching lines @@
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
   if (source->GetResponseCode() >= 500) {
     // Now running ServerUnavailable test.
     // It takes more than 1 second to finish all 11 requests.
     EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
     EXPECT_TRUE(source->GetStatus().is_success());
     std::string data;
     EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
     delete fetcher_;
-    io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+    io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   } else {
     // Now running Overload test.
     static int count = 0;
     count++;
     if (count < 20) {
       fetcher_->StartWithRequestContextGetter(new TestURLRequestContextGetter(
           io_message_loop_proxy()));
     } else {
       // We have already sent 20 requests continuously. And we expect that
       // it takes more than 1 second due to the overload protection settings.
@@ skipping 26 matching lines @@
     EXPECT_GT(fetcher_->GetBackoffDelay().InMicroseconds(), 0);
     std::string data;
     EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
   } else {
     // We should not get here!
     ADD_FAILURE();
   }
 
   delete fetcher_;
-  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 
 URLFetcherBadHTTPSTest::URLFetcherBadHTTPSTest() {
   PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
   cert_dir_ = cert_dir_.AppendASCII("chrome");
   cert_dir_ = cert_dir_.AppendASCII("test");
   cert_dir_ = cert_dir_.AppendASCII("data");
   cert_dir_ = cert_dir_.AppendASCII("ssl");
   cert_dir_ = cert_dir_.AppendASCII("certificates");
 }
 
 // The "server certificate expired" error should result in automatic
 // cancellation of the request by
 // net::URLRequest::Delegate::OnSSLCertificateError.
 void URLFetcherBadHTTPSTest::OnURLFetchComplete(
     const content::URLFetcher* source) {
   // This part is different from URLFetcherTest::OnURLFetchComplete
   // because this test expects the request to be cancelled.
   EXPECT_EQ(net::URLRequestStatus::CANCELED, source->GetStatus().status());
   EXPECT_EQ(net::ERR_ABORTED, source->GetStatus().error());
   EXPECT_EQ(-1, source->GetResponseCode());
   EXPECT_TRUE(source->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 
   // The rest is the same as URLFetcherTest::OnURLFetchComplete.
   delete fetcher_;
-  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
   CancelTestURLRequestContextGetter* context_getter =
       new CancelTestURLRequestContextGetter(io_message_loop_proxy());
   fetcher_->SetRequestContext(context_getter);
   fetcher_->SetMaxRetries(2);
   fetcher_->Start();
   // We need to wait for the creation of the net::URLRequestContext, since we
   // rely on it being destroyed as a signal to end the test.
   context_getter->WaitForContextCreation();
   CancelRequest();
 }
 
 void URLFetcherCancelTest::OnURLFetchComplete(
     const content::URLFetcher* source) {
   // We should have cancelled the request before completion.
   ADD_FAILURE();
   delete fetcher_;
-  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void URLFetcherCancelTest::CancelRequest() {
   delete fetcher_;
   // The URLFetcher's test context will post a Quit task once it is
   // deleted. So if this test simply hangs, it means cancellation
   // did not work.
 }
 
 void URLFetcherMultipleAttemptTest::OnURLFetchComplete(
     const content::URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
   if (!data.empty() && data_.empty()) {
     data_ = data;
     fetcher_->StartWithRequestContextGetter(
         new TestURLRequestContextGetter(io_message_loop_proxy()));
   } else {
     EXPECT_EQ(data, data_);
     delete fetcher_;  // Have to delete this here and not in the destructor,
                       // because the destructor won't necessarily run on the
                       // same thread that CreateFetcher() did.
 
-    io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+    io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     // If the current message loop is not the IO loop, it will be shut down when
     // the main loop returns and this thread subsequently goes out of scope.
   }
 }
 
 void URLFetcherTempFileTest::OnURLFetchComplete(
     const content::URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(source->GetResponseCode(), 200);
 
   EXPECT_TRUE(source->GetResponseAsFilePath(
       take_ownership_of_temp_file_, &temp_file_));
 
   EXPECT_TRUE(file_util::ContentsEqual(expected_file_, temp_file_));
 
   delete fetcher_;
 
-  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(test_server.GetURL("defaultresponse"));
@@ skipping 239 matching lines @@
       FROM_HERE,
       base::Bind(&CancelAllOnIO),
       base::Bind(&MessageLoop::Quit,
                  base::Unretained(MessageLoop::current())));
   MessageLoop::current()->Run();
   EXPECT_EQ(0, GetNumFetcherCores());
   delete fetcher_;
 }
 
 }  // namespace.