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

net/url_request/url_request_unittest.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <stdlib.h>
 
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_layer.h"
 #include "net/url_request/url_request.h"
 #include "net/proxy/proxy_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "googleurl/src/url_util.h"
 
 const int kHTTPDefaultPort = 1337;
 const int kFTPDefaultPort = 1338;
 
@@ skipping 21 matching lines @@
   TestDelegate()
       : cancel_in_rr_(false),
         cancel_in_rs_(false),
         cancel_in_rd_(false),
         cancel_in_rd_pending_(false),
         quit_on_complete_(true),
         response_started_count_(0),
         received_bytes_count_(0),
         received_redirect_count_(0),
         received_data_before_response_(false),
-        request_failed_(false) {
+        request_failed_(false),
+        buf_(new net::IOBuffer(kBufferSize)) {
   }
 
   virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url) {
     received_redirect_count_++;
     if (cancel_in_rr_)
       request->Cancel();
   }
 
   virtual void OnResponseStarted(URLRequest* request) {
     // It doesn't make sense for the request to have IO pending at this point.
     DCHECK(!request->status().is_io_pending());
 
     response_started_count_++;
     if (cancel_in_rs_) {
       request->Cancel();
       OnResponseCompleted(request);
     } else if (!request->status().is_success()) {
       DCHECK(request->status().status() == URLRequestStatus::FAILED ||
              request->status().status() == URLRequestStatus::CANCELED);
       request_failed_ = true;
       OnResponseCompleted(request);
     } else {
       // Initiate the first read.
       int bytes_read = 0;
-      if (request->Read(buf_, sizeof(buf_), &bytes_read))
+      if (request->Read(buf_, kBufferSize, &bytes_read))
         OnReadCompleted(request, bytes_read);
       else if (!request->status().is_io_pending())
         OnResponseCompleted(request);
     }
   }
 
   virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
     // It doesn't make sense for the request to have IO pending at this point.
     DCHECK(!request->status().is_io_pending());
 
     if (response_started_count_ == 0)
       received_data_before_response_ = true;
 
     if (cancel_in_rd_)
       request->Cancel();
 
     if (bytes_read >= 0) {
       // There is data to read.
       received_bytes_count_ += bytes_read;
 
       // consume the data
-      data_received_.append(buf_, bytes_read);
+      data_received_.append(buf_->data(), bytes_read);
     }
 
     // If it was not end of stream, request to read more.
     if (request->status().is_success() && bytes_read > 0) {
       bytes_read = 0;
-      while (request->Read(buf_, sizeof(buf_), &bytes_read)) {
+      while (request->Read(buf_, kBufferSize, &bytes_read)) {
         if (bytes_read > 0) {
-          data_received_.append(buf_, bytes_read);
+          data_received_.append(buf_->data(), bytes_read);
           received_bytes_count_ += bytes_read;
         } else {
           break;
         }
       }
     }
     if (!request->status().is_io_pending())
       OnResponseCompleted(request);
     else if (cancel_in_rd_pending_)
       request->Cancel();
@@ skipping 35 matching lines @@
   const std::string& data_received() const { return data_received_; }
   int bytes_received() const { return static_cast<int>(data_received_.size()); }
   int response_started_count() const { return response_started_count_; }
   int received_redirect_count() const { return received_redirect_count_; }
   bool received_data_before_response() const {
     return received_data_before_response_;
   }
   bool request_failed() const { return request_failed_; }
 
  private:
+  static const int kBufferSize = 4096;
   // options for controlling behavior
   bool cancel_in_rr_;
   bool cancel_in_rs_;
   bool cancel_in_rd_;
   bool cancel_in_rd_pending_;
   bool quit_on_complete_;
 
   std::wstring username_;
   std::wstring password_;
 
   // tracks status of callbacks
   int response_started_count_;
   int received_bytes_count_;
   int received_redirect_count_;
   bool received_data_before_response_;
   bool request_failed_;
   std::string data_received_;
 
   // our read buffer
-  char buf_[4096];
+  scoped_refptr<net::IOBuffer> buf_;
 };
 
 // This object bounds the lifetime of an external python-based HTTP/FTP server
 // that can provide various responses useful for testing.
 class BaseTestServer : public base::ProcessFilter,
                        public base::RefCounted<BaseTestServer> {
  protected:
   BaseTestServer()
       : process_handle_(NULL) {
   }
@@ skipping 473 matching lines @@
     command_line->push_back("python");
     command_line->push_back(WideToUTF8(testserver_path));
     command_line->push_back(" -f ");
     command_line->push_back("--data-dir=" + WideToUTF8(test_data_directory));
     command_line->push_back("--port=" + port_str_);
   }
 #endif
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_