Extend the use of IOBuffers to the code underneath...

net/http/http_network_transaction_unittest.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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/completion_callback.h"
 #include "net/base/ssl_client_socket.h"
@@ skipping 103 matching lines @@
     connected_ = false;
     callback_ = NULL;
   }
   virtual bool IsConnected() const {
     return connected_;
   }
   virtual bool IsConnectedAndIdle() const {
     return connected_;
   }
   // Socket methods:
-  virtual int Read(char* buf, int buf_len,
+  virtual int Read(IOBuffer* buf, int buf_len,
                    CompletionCallback* callback) = 0;
-  virtual int Write(const char* buf, int buf_len,
+  virtual int Write(IOBuffer* buf, int buf_len,
                     CompletionCallback* callback) = 0;
 
 #if defined(OS_LINUX)
   virtual int GetPeerName(struct sockaddr *name, socklen_t *namelen) {
     memset(reinterpret_cast<char *>(name), 0, *namelen);
     return OK;
   }
 #endif
 
 
@@ skipping 34 matching lines @@
       return OK;
     connected_ = true;
     if (data_->connect.async) {
       RunCallbackAsync(callback, data_->connect.result);
       return ERR_IO_PENDING;
     }
     return data_->connect.result;
   }
 
   // Socket methods:
-  virtual int Read(char* buf, int buf_len, CompletionCallback* callback) {
+  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback) {
     DCHECK(!callback_);
     MockRead& r = data_->reads[read_index_];
     int result = r.result;
     if (r.data) {
       if (r.data_len - read_offset_ > 0) {
         result = std::min(buf_len, r.data_len - read_offset_);
-        memcpy(buf, r.data + read_offset_, result);
+        memcpy(buf->data(), r.data + read_offset_, result);
         read_offset_ += result;
         if (read_offset_ == r.data_len) {
           read_index_++;
           read_offset_ = 0;
         }
       } else {
         result = 0;  // EOF
       }
     }
     if (r.async) {
       RunCallbackAsync(callback, result);
       return ERR_IO_PENDING;
     }
     return result;
   }
 
-  virtual int Write(const char* buf, int buf_len,
+  virtual int Write(IOBuffer* buf, int buf_len,
                     CompletionCallback* callback) {
     DCHECK(buf);
     DCHECK(buf_len > 0);
     DCHECK(!callback_);
     // Not using mock writes; succeed synchronously.
     if (!data_->writes)
       return buf_len;
 
     // Check that what we are writing matches the expectation.
     // Then give the mocked return value.
     MockWrite& w = data_->writes[write_index_++];
     int result = w.result;
     if (w.data) {
       std::string expected_data(w.data, w.data_len);
-      std::string actual_data(buf, buf_len);
+      std::string actual_data(buf->data(), buf_len);
       EXPECT_EQ(expected_data, actual_data);
       if (expected_data != actual_data)
         return ERR_UNEXPECTED;
       if (result == OK)
         result = w.data_len;
     }
     if (w.async) {
       RunCallbackAsync(callback, result);
       return ERR_IO_PENDING;
     }
@@ skipping 72 matching lines @@
     return rv;
   }
 
   virtual void Disconnect() {
     MockClientSocket::Disconnect();
     if (transport_ != NULL)
       transport_->Disconnect();
   }
 
   // Socket methods:
-  virtual int Read(char* buf, int buf_len, CompletionCallback* callback) {
+  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback) {
     DCHECK(!callback_);
     return transport_->Read(buf, buf_len, callback);
   }
 
-  virtual int Write(const char* buf, int buf_len,
+  virtual int Write(IOBuffer* buf, int buf_len,
                     CompletionCallback* callback) {
     DCHECK(!callback_);
     return transport_->Write(buf, buf_len, callback);
   }
 
  private:
   scoped_ptr<ClientSocket> transport_;
   MockSSLSocket* data_;
 };
 
@@ skipping 2579 matching lines @@
 }
 
 // Test the ResetStateForRestart() private method.
 TEST_F(HttpNetworkTransactionTest, ResetStateForRestart) {
   // Create a transaction (the dependencies aren't important).
   scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
   // Setup some state (which we expect ResetStateForRestart() will clear).
-  trans->header_buf_.reset(static_cast<char*>(malloc(10)));
+  trans->header_buf_->Realloc(10);
   trans->header_buf_capacity_ = 10;
   trans->header_buf_len_ = 3;
   trans->header_buf_body_offset_ = 11;
   trans->header_buf_http_offset_ = 0;
   trans->response_body_length_ = 100;
   trans->response_body_read_ = 1;
   trans->read_buf_ = new IOBuffer(15);
   trans->read_buf_len_ = 15;
-  trans->request_headers_ = "Authorization: NTLM";
+  trans->request_headers_->headers_ = "Authorization: NTLM";
   trans->request_headers_bytes_sent_ = 3;
 
   // Setup state in response_
   trans->response_.auth_challenge = new AuthChallengeInfo();
   trans->response_.ssl_info.cert_status = -15;
   trans->response_.response_time = base::Time::Now();
   trans->response_.was_cached = true;  // (Wouldn't ever actually be true...)
 
   { // Setup state for response_.vary_data
     HttpRequestInfo request;
     std::string temp("HTTP/1.1 200 OK\nVary: foo, bar\n\n");
     std::replace(temp.begin(), temp.end(), '\n', '\0');
     scoped_refptr<HttpResponseHeaders> response = new HttpResponseHeaders(temp);
     request.extra_headers = "Foo: 1\nbar: 23";
     EXPECT_TRUE(trans->response_.vary_data.Init(request, *response));
   }
 
   // Cause the above state to be reset.
   trans->ResetStateForRestart();
 
   // Verify that the state that needed to be reset, has been reset.
-  EXPECT_EQ(NULL, trans->header_buf_.get());
+  EXPECT_EQ(NULL, trans->header_buf_->headers());
   EXPECT_EQ(0, trans->header_buf_capacity_);
   EXPECT_EQ(0, trans->header_buf_len_);
   EXPECT_EQ(-1, trans->header_buf_body_offset_);
   EXPECT_EQ(-1, trans->header_buf_http_offset_);
   EXPECT_EQ(-1, trans->response_body_length_);
   EXPECT_EQ(0, trans->response_body_read_);
   EXPECT_EQ(NULL, trans->read_buf_.get());
   EXPECT_EQ(0, trans->read_buf_len_);
-  EXPECT_EQ("", trans->request_headers_);
+  EXPECT_EQ("", trans->request_headers_->headers_);
   EXPECT_EQ(0U, trans->request_headers_bytes_sent_);
   EXPECT_EQ(NULL, trans->response_.auth_challenge.get());
   EXPECT_EQ(NULL, trans->response_.headers.get());
   EXPECT_EQ(false, trans->response_.was_cached);
   EXPECT_EQ(base::kInvalidPlatformFileValue,
             trans->response_.response_data_file);
   EXPECT_EQ(0, trans->response_.ssl_info.cert_status);
   EXPECT_FALSE(trans->response_.vary_data.is_valid());
 }
 
@@ skipping 126 matching lines @@
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
 
     EXPECT_FALSE(response == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 }  // namespace net