chrome: Use base::MessageLoop. (Part 3)

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
@@ skipping 247 matching lines @@
       if (rv != net::ERR_IO_PENDING)
         Finish(WRITE_FAILED, rv);
       break;
     }
     DCHECK_EQ(bytes_to_send_, 0u);
   };
 }
 
 void NetworkStats::SendNextPacketAfterDelay() {
   if (current_test_ == PACED_PACKET_TEST) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&NetworkStats::SendPacket, weak_factory_.GetWeakPtr()),
         average_time_);
     return;
   }
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&NetworkStats::SendPacket, weak_factory_.GetWeakPtr()));
 }
 
 bool NetworkStats::ReadComplete(int result) {
   DCHECK(socket_.get());
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result < 0) {
     Finish(READ_FAILED, result);
     return true;
@@ skipping 31 matching lines @@
   }
   return false;
 }
 
 void NetworkStats::OnReadComplete(int result) {
   if (!ReadComplete(result)) {
     // Called ReadData() via PostDelayedTask() to avoid recursion. Added a delay
     // of 1ms so that the time-out will fire before we have time to really hog
     // the CPU too extensively (waiting for the time-out) in case of an infinite
     // loop.
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&NetworkStats::ReadData, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(1));
   }
 }
 
 void NetworkStats::OnWriteComplete(int result) {
   DCHECK(socket_.get());
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result < 0) {
     Finish(WRITE_FAILED, result);
     return;
   }
 
   DidSendData(result);
   if (bytes_to_send_) {
     int rv = SendData();
     if (rv < 0) {
       if (rv != net::ERR_IO_PENDING)
         Finish(WRITE_FAILED, rv);
       return;
     }
     DCHECK_EQ(rv, net::OK);
     DCHECK_EQ(bytes_to_send_, 0u);
   }
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&NetworkStats::SendPacket, weak_factory_.GetWeakPtr()));
 }
 
 void NetworkStats::ReadData() {
   int rv;
   do {
     if (!socket_.get())
       break;
 
@@ skipping 60 matching lines @@
 }
 
 void NetworkStats::DidSendData(int bytes_sent) {
   write_buffer_->DidConsume(bytes_sent);
   if (!write_buffer_->BytesRemaining())
     write_buffer_ = NULL;
   bytes_to_send_ -= bytes_sent;
 }
 
 void NetworkStats::StartReadDataTimer(int milliseconds) {
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&NetworkStats::OnReadDataTimeout,
                  weak_factory_.GetWeakPtr(),
                  base_packet_number_),
       base::TimeDelta::FromMilliseconds(milliseconds));
 }
 
 void NetworkStats::OnReadDataTimeout(uint32 test_base_packet_number) {
   if (test_base_packet_number != base_packet_number_)
     return;
@@ skipping 196 matching lines @@
 void NetworkStats::Finish(Status status, int result) {
   // Set the base_packet_number_ for the start of next test. Changing the
   // |base_packet_number_| indicates to OnReadDataTimeout that the Finish has
   // already been called for the test and that it doesn't need to call Finish
   // again.
   base_packet_number_ = packet_number_ + 1;
   RecordHistograms(PROTOCOL_UDP, status, result);
 
   if (next_test() == NON_PACED_PACKET_TEST ||
       next_test() == PACED_PACKET_TEST) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&NetworkStats::RestartPacketTest,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   DoFinishCallback(result);
 
   // Close the socket so that there are no more IO operations.
   net::UDPClientSocket* udp_socket =
@@ skipping 349 matching lines @@
         udp_stats_client->Start(
             host_resolver, server_address, histogram_port, has_proxy_server,
             kLargeTestBytesToSend, kMaximumSequentialPackets,
             net::CompletionCallback());
       }
       break;
   }
 }
 
 }  // namespace chrome_browser_net