net: Move ownership of UploadDataStream from URLRequestHttpJob to URLRequest

chrome/browser/extensions/api/web_request/upload_data_presenter.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 "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/web_request/form_data_parser.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
-#include "net/base/upload_element.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_file_element_reader.h"
 #include "net/url_request/url_request.h"
 
 using base::BinaryValue;
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 
 namespace keys = extension_web_request_api_constants;
 
@@ skipping 30 matching lines @@
 UploadDataPresenter::~UploadDataPresenter() {}
 
 // Implementation of RawDataPresenter.
 
 RawDataPresenter::RawDataPresenter()
   : success_(true),
     list_(new base::ListValue) {
 }
 RawDataPresenter::~RawDataPresenter() {}
 
-void RawDataPresenter::FeedNext(const net::UploadElement& element) {
+void RawDataPresenter::FeedNext(const net::UploadElementReader& reader) {
   if (!success_)
     return;
 
-  switch (element.type()) {
-    case net::UploadElement::TYPE_BYTES:
-      FeedNextBytes(element.bytes(), element.bytes_length());
-      break;
-    case net::UploadElement::TYPE_FILE:
-      // Insert the file path instead of the contents, which may be too large.
-      FeedNextFile(element.file_path().AsUTF8Unsafe());
-      break;
+  if (reader.AsBytesReader()) {
+    const net::UploadBytesElementReader* bytes_reader = reader.AsBytesReader();
+    FeedNextBytes(bytes_reader->bytes(), bytes_reader->length());
+  } else if (reader.AsFileReader()) {
+    // Insert the file path instead of the contents, which may be too large.
+    const net::UploadFileElementReader* file_reader = reader.AsFileReader();
+    FeedNextFile(file_reader->path().AsUTF8Unsafe());
+  } else {
+    NOTIMPLEMENTED();
   }
 }
 
 bool RawDataPresenter::Succeeded() {
   return success_;
 }
 
 scoped_ptr<Value> RawDataPresenter::Result() {
   if (!success_)
     return scoped_ptr<Value>();
@@ skipping 22 matching lines @@
 // Implementation of ParsedDataPresenter.
 
 ParsedDataPresenter::ParsedDataPresenter(const net::URLRequest& request)
   : parser_(FormDataParser::Create(request)),
     success_(parser_.get() != NULL),
     dictionary_(success_ ? new DictionaryValue() : NULL) {
 }
 
 ParsedDataPresenter::~ParsedDataPresenter() {}
 
-void ParsedDataPresenter::FeedNext(const net::UploadElement& element) {
+void ParsedDataPresenter::FeedNext(const net::UploadElementReader& reader) {
   if (!success_)
     return;
 
-  if (element.type() != net::UploadElement::TYPE_BYTES) {
+  const net::UploadBytesElementReader* bytes_reader = reader.AsBytesReader();
+  if (!bytes_reader) {
     return;
   }
-  if (!parser_->SetSource(base::StringPiece(element.bytes(),
-                                            element.bytes_length()))) {
+  if (!parser_->SetSource(base::StringPiece(bytes_reader->bytes(),
+                                            bytes_reader->length()))) {
     Abort();
     return;
   }
 
   FormDataParser::Result result;
   while (parser_->GetNextNameValue(&result)) {
     GetOrCreateList(dictionary_.get(), result.name())->Append(
         new StringValue(result.value()));
   }
 }
@@ skipping 23 matching lines @@
     dictionary_(success_ ? new DictionaryValue() : NULL) {
 }
 
 void ParsedDataPresenter::Abort() {
   success_ = false;
   dictionary_.reset();
   parser_.reset();
 }
 
 }  // namespace extensions