Change URLRequest to use a ref-counted buffer for actual IO....

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using URLRequest, meaning it is a "simple" version
 // that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because URLRequest only provides an asynchronous resource loading API, this
@@ skipping 19 matching lines @@
 // perform URL loads.  See renderer/resource_dispatcher.h for details on an
 // alternate implementation that defers fetching to another process.
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/cookie_monster.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/tools/test_shell/test_shell_request_context.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using net::HttpResponseHeaders;
 
 namespace {
@@ skipping 47 matching lines @@
   scoped_refptr<net::UploadData> upload;
 };
 
 // The RequestProxy does most of its work on the IO thread.  The Start and
 // Cancel methods are proxied over to the IO thread, where an URLRequest object
 // is instantiated.
 class RequestProxy : public URLRequest::Delegate,
                      public base::RefCountedThreadSafe<RequestProxy> {
  public:
   // Takes ownership of the params.
-  RequestProxy() {
+  RequestProxy() : buf_(new net::IOBuffer(kDataSize)) {
   }
 
   virtual ~RequestProxy() {
     // If we have a request, then we'd better be on the io thread!
     DCHECK(!request_.get() ||
            MessageLoop::current() == io_thread->message_loop());
   }
 
   void DropPeer() {
     peer_ = NULL;
@@ skipping 30 matching lines @@
     if (peer_)
       peer_->OnReceivedResponse(info, content_filtered);
   }
 
   void NotifyReceivedData(int bytes_read) {
     if (!peer_)
       return;
 
     // Make a local copy of buf_, since AsyncReadData reuses it.
     scoped_array<char> buf_copy(new char[bytes_read]);
-    memcpy(buf_copy.get(), buf_, bytes_read);
+    memcpy(buf_copy.get(), buf_->data(), bytes_read);
 
     // Continue reading more data into buf_
     // Note: Doing this before notifying our peer ensures our load events get
     // dispatched in a manner consistent with DumpRenderTree (and also avoids a
     // race condition).  If the order of the next 2 functions were reversed, the
     // peer could generate new requests in reponse to the received data, which
     // when run on the io thread, could race against this function in doing
     // another InvokeLater.  See bug 769249.
     io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::AsyncReadData));
@@ skipping 35 matching lines @@
     Done();
   }
 
   void AsyncReadData() {
     // This can be null in cases where the request is already done.
     if (!request_.get())
       return;
 
     if (request_->status().is_success()) {
       int bytes_read;
-      if (request_->Read(buf_, sizeof(buf_), &bytes_read) && bytes_read) {
+      if (request_->Read(buf_, kDataSize, &bytes_read) && bytes_read) {
         OnReceivedData(bytes_read);
       } else if (!request_->status().is_io_pending()) {
         Done();
       }  // else wait for OnReadCompleted
     } else {
       Done();
     }
   }
 
   // --------------------------------------------------------------------------
@@ skipping 64 matching lines @@
     OnCompletedRequest(request_->status());
     request_.reset();  // destroy on the io thread
   }
 
   scoped_ptr<URLRequest> request_;
 
   // Size of our async IO data buffers
   static const int kDataSize = 16*1024;
 
   // read buffer for async IO
-  char buf_[kDataSize];
+  scoped_refptr<net::IOBuffer> buf_;
 
   MessageLoop* owner_loop_;
 
   // This is our peer in WebKit (implemented as ResourceHandleInternal). We do
   // not manage its lifetime, and we may only access it from the owner's
   // message loop (owner_loop_).
   ResourceLoaderBridge::Peer* peer_;
 };
 
 //-----------------------------------------------------------------------------
@@ skipping 16 matching lines @@
     result_->url = new_url;
   }
 
   virtual void OnReceivedResponse(
       const ResourceLoaderBridge::ResponseInfo& info,
       bool content_filtered) {
     *static_cast<ResourceLoaderBridge::ResponseInfo*>(result_) = info;
   }
 
   virtual void OnReceivedData(int bytes_read) {
-    result_->data.append(buf_, bytes_read);
+    result_->data.append(buf_->data(), bytes_read);
     AsyncReadData();  // read more (may recurse)
   }
 
   virtual void OnCompletedRequest(const URLRequestStatus& status) {
     result_->status = status;
     event_.Signal();
   }
 
  private:
   ResourceLoaderBridge::SyncLoadResponse* result_;
@@ skipping 199 matching lines @@
 // static
 void SimpleResourceLoaderBridge::Shutdown() {
   if (io_thread) {
     delete io_thread;
     io_thread = NULL;
 
     DCHECK(!request_context) << "should have been nulled by thread dtor";
   }
 }