net: Change argument of URLRequest::set_upload from UploadData to UploadDataStream

net/ocsp/nss_ocsp.cc

 // Copyright (c) 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 "net/ocsp/nss_ocsp.h"
 
 #include <certt.h>
 #include <certdb.h>
 #include <ocsp.h>
 #include <nspr.h>
@@ skipping 15 matching lines @@
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 namespace {
 
 // Protects |g_request_context|.
@@ skipping 136 matching lines @@
         timeout_(timeout),
         request_(NULL),
         buffer_(new IOBuffer(kRecvBufferSize)),
         response_code_(-1),
         cv_(&lock_),
         io_loop_(NULL),
         finished_(false) {}
 
   void SetPostData(const char* http_data, PRUint32 http_data_len,
                    const char* http_content_type) {
+    // |upload_content_| should not be modified if |request_| is active.
+    DCHECK(!request_);
     upload_content_.assign(http_data, http_data_len);
     upload_content_type_.assign(http_content_type);
   }
 
   void AddHeader(const char* http_header_name, const char* http_header_value) {
     extra_request_headers_.SetHeader(http_header_name,
                                      http_header_value);
   }
 
   void Start() {
@@ skipping 193 matching lines @@
                              LOAD_DO_NOT_SEND_COOKIES);
 
     if (http_request_method_ == "POST") {
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method("POST");
       extra_request_headers_.SetHeader(
           HttpRequestHeaders::kContentType, upload_content_type_);
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(upload_content_.data(), upload_content_.size());
-      request_->set_upload(upload_data);
+      scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
+          upload_content_.data(), upload_content_.size()));
+      request_->set_upload(make_scoped_ptr(
+          UploadDataStream::CreateWithReader(reader.Pass(), 0)));
     }
     if (!extra_request_headers_.IsEmpty())
       request_->SetExtraRequestHeaders(extra_request_headers_);
 
     request_->Start();
     AddRef();  // Release after |request_| deleted.
   }
 
   GURL url_;                      // The URL we eventually wound up at
   std::string http_request_method_;
   base::TimeDelta timeout_;       // The timeout for OCSP
   URLRequest* request_;           // The actual request this wraps
   scoped_refptr<IOBuffer> buffer_;  // Read buffer
   HttpRequestHeaders extra_request_headers_;
-  std::string upload_content_;    // HTTP POST payload
+
+  // HTTP POST payload. |request_| reads bytes from this.
+  std::string upload_content_;
   std::string upload_content_type_;  // MIME type of POST payload
 
   int response_code_;             // HTTP status code for the request
   std::string response_content_type_;
   scoped_refptr<HttpResponseHeaders> response_headers_;
   std::string data_;              // Results of the request
 
   // |lock_| protects |finished_| and |io_loop_|.
   mutable base::Lock lock_;
   base::ConditionVariable cv_;
@@ skipping 525 matching lines @@
 void SetURLRequestContextForNSSHttpIO(URLRequestContext* request_context) {
   pthread_mutex_lock(&g_request_context_lock);
   if (request_context) {
     DCHECK(!g_request_context);
   }
   g_request_context = request_context;
   pthread_mutex_unlock(&g_request_context_lock);
 }
 
 }  // namespace net