Add CHECKs to the ResourceHandler derived classes to see which is returning a NULL IOBuffer:data_.

chrome/browser/renderer_host/async_resource_handler.cc

 // Copyright (c) 2006-2008 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/renderer_host/async_resource_handler.h"
 
+#include "base/logging.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "chrome/common/render_messages.h"
 #include "net/base/io_buffer.h"
 
-SharedIOBuffer* AsyncResourceHandler::spare_read_buffer_;
+// When reading, we don't know if we are going to get EOF (0 bytes read), so
+// we typically have a buffer that we allocated but did not use.  We keep
+// this buffer around for the next read as a small optimization.
+static SharedIOBuffer* g_spare_read_buffer = NULL;
 
 // Our version of IOBuffer that uses shared memory.
 class SharedIOBuffer : public net::IOBuffer {
  public:
   SharedIOBuffer(int buffer_size) : net::IOBuffer(), ok_(false) {
     if (shared_memory_.Create(std::wstring(), false, false, buffer_size) &&
         shared_memory_.Map(buffer_size)) {
       ok_ = true;
       data_ = reinterpret_cast<char*>(shared_memory_.memory());
     }
   }
   ~SharedIOBuffer() {
+    // TODO(willchan): Remove after debugging bug 16371.
+    CHECK(g_spare_read_buffer != this);
     data_ = NULL;
   }
 
   base::SharedMemory* shared_memory() { return &shared_memory_; }
   bool ok() { return ok_; }
 
  private:
   base::SharedMemory shared_memory_;
   bool ok_;
 };
@@ skipping 31 matching lines @@
                                              ResourceResponse* response) {
   receiver_->Send(new ViewMsg_Resource_ReceivedResponse(
       routing_id_, request_id, response->response_head));
   return true;
 }
 
 bool AsyncResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
                                       int* buf_size, int min_size) {
   DCHECK(min_size == -1);
   static const int kReadBufSize = 32768;
-  if (spare_read_buffer_) {
+  if (g_spare_read_buffer) {
     DCHECK(!read_buffer_);
-    read_buffer_.swap(&spare_read_buffer_);
+    read_buffer_.swap(&g_spare_read_buffer);
+    // TODO(willchan): Remove after debugging bug 16371.
+    CHECK(read_buffer_->data());
   } else {
     read_buffer_ = new SharedIOBuffer(kReadBufSize);
     if (!read_buffer_->ok())
       return false;
+    // TODO(willchan): Remove after debugging bug 16371.
+    CHECK(read_buffer_->data());
   }
   *buf = read_buffer_.get();
   *buf_size = kReadBufSize;
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
   if (!*bytes_read)
     return true;
   DCHECK(read_buffer_.get());
@@ skipping 26 matching lines @@
 bool AsyncResourceHandler::OnResponseCompleted(
     int request_id,
     const URLRequestStatus& status,
     const std::string& security_info) {
   receiver_->Send(new ViewMsg_Resource_RequestComplete(routing_id_,
                                                        request_id,
                                                        status,
                                                        security_info));
 
   // If we still have a read buffer, then see about caching it for later...
-  if (spare_read_buffer_) {
+  if (g_spare_read_buffer) {
     read_buffer_ = NULL;
   } else if (read_buffer_.get()) {
-    read_buffer_.swap(&spare_read_buffer_);
+    read_buffer_.swap(&g_spare_read_buffer);
   }
   return true;
 }
 
 // static
 void AsyncResourceHandler::GlobalCleanup() {
-  if (spare_read_buffer_) {
-    spare_read_buffer_->Release();
-    spare_read_buffer_ = NULL;
+  if (g_spare_read_buffer) {
+    // Avoid the CHECK in SharedIOBuffer::~SharedIOBuffer().
+    SharedIOBuffer* tmp = g_spare_read_buffer;
+    g_spare_read_buffer = NULL;
+    tmp->Release();
   }
 }