Implement HostPortAllocator.

remoting/host/url_fetcher.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 "remoting/host/url_fetcher.h"
 
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace remoting {
 
 const int kBufferSize = 4096;
 
 class UrlFetcher::Core : public base::RefCountedThreadSafe<Core>,
                          public net::URLRequest::Delegate {
  public:
   Core(const GURL& url, Method method);
 
   void SetRequestContext(
       net::URLRequestContextGetter* request_context_getter);
   void SetUploadData(const std::string& upload_content_type,
                      const std::string& upload_content);
+  void SetHeader(const std::string& key, const std::string& value);
   void Start(const UrlFetcher::DoneCallback& done_callback);
 
   void Detach();
 
   // net::UrlRequest::Delegate interface.
   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE;
 
  private:
@@ skipping 13 matching lines @@
   Method method_;
 
   scoped_refptr<base::MessageLoopProxy> delegate_message_loop_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   std::string upload_content_;
   std::string upload_content_type_;
 
+  net::HttpRequestHeaders request_headers_;
+
   scoped_ptr<net::URLRequest> request_;
 
   scoped_refptr<net::IOBuffer> buffer_;
   std::string data_;
 
   UrlFetcher::DoneCallback done_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
@@ skipping 12 matching lines @@
   DCHECK(!request_context_getter_);
   request_context_getter_ = request_context_getter;
 }
 
 void UrlFetcher::Core::SetUploadData(const std::string& upload_content_type,
                                      const std::string& upload_content) {
   upload_content_type_ = upload_content_type;
   upload_content_ = upload_content;
 }
 
+void UrlFetcher::Core::SetHeader(const std::string& key,
+                                 const std::string& value) {
+  request_headers_.SetHeader(key, value);
+}
+
 void UrlFetcher::Core::Start(const UrlFetcher::DoneCallback& done_callback) {
   done_callback_ = done_callback;
   io_message_loop_ = request_context_getter_->GetIOMessageLoopProxy();
   DCHECK(io_message_loop_);
   io_message_loop_->PostTask(FROM_HERE, base::Bind(
       &UrlFetcher::Core::DoStart, this));
 }
 
 void UrlFetcher::Core::Detach() {
   DCHECK(delegate_message_loop_->BelongsToCurrentThread());
@@ skipping 37 matching lines @@
 
   switch (method_) {
     case GET:
       break;
 
     case POST:
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
       request_->set_method("POST");
 
-      net::HttpRequestHeaders headers;
-      headers.SetHeader(net::HttpRequestHeaders::kContentType,
-                        upload_content_type_);
-      request_->SetExtraRequestHeaders(headers);
+      request_headers_.SetHeader(net::HttpRequestHeaders::kContentType,
+                                 upload_content_type_);
 
       request_->AppendBytesToUpload(
           upload_content_.data(), static_cast<int>(upload_content_.length()));
       break;
   }
 
+  request_->SetExtraRequestHeaders(request_headers_);
+
   request_->Start();
 }
 
 void UrlFetcher::Core::ReadResponse() {
   int bytes_read = 0;
   if (request_->status().is_success()) {
     request_->Read(buffer_, kBufferSize, &bytes_read);
   }
   OnReadCompleted(request_.get(), bytes_read);
 }
@@ skipping 24 matching lines @@
 void UrlFetcher::SetRequestContext(
     net::URLRequestContextGetter* request_context_getter) {
   core_->SetRequestContext(request_context_getter);
 }
 
 void UrlFetcher::SetUploadData(const std::string& upload_content_type,
                                const std::string& upload_content) {
   core_->SetUploadData(upload_content_type, upload_content);
 }
 
+void UrlFetcher::SetHeader(const std::string& key, const std::string& value) {
+  core_->SetHeader(key, value);
+}
+
 void UrlFetcher::Start(const DoneCallback& done_callback) {
   core_->Start(done_callback);
 }
 
 }  // namespace remoting