Another attempt to fix a Chrome crash.

chrome/browser/net/network_stats.cc

 // Copyright 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/message_loop.h"
 #include "base/metrics/field_trial.h"
@@ skipping 201 matching lines @@
   return ConnectComplete(rv);
 }
 
 bool NetworkStats::ConnectComplete(int result) {
   if (result < 0) {
     TestPhaseComplete(CONNECT_FAILED, result);
     return false;
   }
 
   if (start_test_after_connect_) {
-    ReadData();  // This ReadData() reads data for all HelloReply and all
-                 // subsequent probe tests.
+    // ReadData() reads data for all HelloReply and all subsequent probe tests.
+    if (ReadData() != net::ERR_IO_PENDING)
+      return false;
     SendHelloRequest();
   } else {
     // For unittesting. Only run the callback, do not destroy it.
     if (!finished_callback_.is_null())
       finished_callback_.Run(result);
   }
   return true;
 }
 
 void NetworkStats::SendHelloRequest() {
@@ skipping 50 matching lines @@
                                       &probe_packet);
   std::string output = probe_message_.MakeEncodedPacket(probe_packet);
 
   StartReadDataTimer(timeout_seconds, current_test_index_);
   probe_request_time_ = base::TimeTicks::Now();
   int result = SendData(output);
   if (result < 0 && result != net::ERR_IO_PENDING)
     TestPhaseComplete(WRITE_FAILED, result);
 }
 
-void NetworkStats::ReadData() {
+int NetworkStats::ReadData() {
   if (!socket_.get())
-    return;
+    return 0;
 
   int rv = 0;
   do {
     DCHECK(!read_buffer_.get());
     read_buffer_ = new net::IOBuffer(kMaxMessageSize);
 
     rv = socket_->Read(
         read_buffer_.get(),
         kMaxMessageSize,
         base::Bind(&NetworkStats::OnReadComplete, base::Unretained(this)));
   } while (rv > 0 && !ReadComplete(rv));
+  return rv;
 }
 
 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.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&NetworkStats::ReadData, weak_factory_.GetWeakPtr()),
+        base::Bind(base::IgnoreResult(&NetworkStats::ReadData),
+                   weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(1));
   }
 }
 
 bool NetworkStats::ReadComplete(int result) {
   DCHECK(socket_.get());
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result < 0) {
     // Something is wrong, finish the test.
     read_buffer_ = NULL;
@@ skipping 84 matching lines @@
 
 int NetworkStats::SendData(const std::string& output) {
   if (write_buffer_.get() || !socket_.get())
     return net::ERR_UNEXPECTED;
   scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(output));
   write_buffer_ = new net::DrainableIOBuffer(buffer.get(), buffer->size());
 
   int bytes_written = socket_->Write(
       write_buffer_.get(),
       write_buffer_->BytesRemaining(),
-      base::Bind(&NetworkStats::OnWriteComplete, base::Unretained(this)));
+      base::Bind(&NetworkStats::OnWriteComplete, weak_factory_.GetWeakPtr()));
   if (bytes_written < 0)
     return bytes_written;
   UpdateSendBuffer(bytes_written);
   return net::OK;
 }
 
 void NetworkStats::OnWriteComplete(int result) {
   DCHECK(socket_.get());
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result < 0) {
@@ skipping 420 matching lines @@
       new NetworkStats(net::ClientSocketFactory::GetDefaultFactory());
   udp_stats_client->Start(host_resolver,
                           server_address,
                           histogram_port,
                           has_proxy_server,
                           kProbePacketBytes[probe_choice],
                           net::CompletionCallback());
 }
 
 }  // namespace chrome_browser_net