Allow URLRequests from one context to have different NetworkDelegates.

mojo/services/network/url_loader_impl.cc

 // Copyright 2014 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 "mojo/services/network/url_loader_impl.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
+#include "net/url_request/url_request_context.h"
 
 namespace mojo {
 namespace {
 
 const uint32_t kMaxReadSize = 64 * 1024;
 
 // Generates an URLResponsePtr from the response state of a net::URLRequest.
 URLResponsePtr MakeURLResponse(const net::URLRequest* url_request) {
   URLResponsePtr response(URLResponse::New());
   response->url = String::From(url_request->url());
@@ skipping 49 matching lines @@
   virtual uint64 BytesRemaining() const OVERRIDE {
     return num_bytes_ - offset_;
   }
   virtual bool IsInMemory() const OVERRIDE {
     return false;
   }
   virtual int Read(net::IOBuffer* buf,
                    int buf_length,
                    const net::CompletionCallback& callback) OVERRIDE {
     uint32_t bytes_read =
-        std::min(BytesRemaining(), static_cast<uint64>(buf_length));
+        std::min(static_cast<uint32_t>(BytesRemaining()),
+                 static_cast<uint32_t>(buf_length));
     if (bytes_read > 0) {
       ReadDataRaw(pipe_.get(), buf->data(), &bytes_read,
                   MOJO_READ_DATA_FLAG_NONE);
     }
 
     offset_ += bytes_read;
     return bytes_read;
   }
 
  private:
@@ skipping 74 matching lines @@
   if (url_request_) {
     SendError(net::ERR_UNEXPECTED, callback);
     return;
   }
 
   if (!request) {
     SendError(net::ERR_INVALID_ARGUMENT, callback);
     return;
   }
 
-  url_request_.reset(
-      new net::URLRequest(GURL(request->url),
-                          net::DEFAULT_PRIORITY,
-                          this,
-                          context_->url_request_context()));
+  url_request_ = context_->url_request_context()->CreateRequest(
+      GURL(request->url),
+      net::DEFAULT_PRIORITY,
+      this,
+      NULL);
   url_request_->set_method(request->method);
   if (request->headers) {
     net::HttpRequestHeaders headers;
     for (size_t i = 0; i < request->headers.size(); ++i)
       headers.AddHeaderFromString(request->headers[i].To<base::StringPiece>());
     url_request_->SetExtraRequestHeaders(headers);
   }
   if (request->body) {
     ScopedVector<net::UploadElementReader> element_readers;
     for (size_t i = 0; i < request->body.size(); ++i) {
@@ skipping 176 matching lines @@
   if (completed_synchronously) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&URLLoaderImpl::ReadMore, weak_ptr_factory_.GetWeakPtr()));
   } else {
     ReadMore();
   }
 }
 
 }  // namespace mojo