Allow no content-type for POST, PUT and PATCH methods.

net/url_request/url_fetcher_core.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/url_request/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/files/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 312 matching lines @@
   if (network_task_runner_->RunsTasksOnCurrentThread()) {
     CancelURLRequest();
   } else {
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&URLFetcherCore::CancelURLRequest, this));
   }
 }
 
 void URLFetcherCore::SetUploadData(const std::string& upload_content_type,
                                    const std::string& upload_content) {
+  DCHECK(!is_chunked_upload_);
+  DCHECK(!upload_content_);
+  DCHECK(upload_content_type_.empty());
+
+  // Empty |upload_content_type| is allowed iff the |upload_content| is empty.
+  DCHECK(upload_content.empty() || !upload_content_type.empty());
+
+  upload_content_type_ = upload_content_type;
   scoped_ptr<UploadElementReader> reader(
       UploadOwnedBytesElementReader::CreateWithString(upload_content));
-  SetUploadDataStream(
-      upload_content_type,
-      make_scoped_ptr(UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+  upload_content_.reset(UploadDataStream::CreateWithReader(reader.Pass(), 0));
 }
 
 void URLFetcherCore::SetUploadDataStream(
     const std::string& upload_content_type,
     scoped_ptr<UploadDataStream> upload_content) {
   DCHECK(!is_chunked_upload_);
   DCHECK(!upload_content_);
   DCHECK(upload_content_type_.empty());
+
+  // Empty |upload_content_type| is not allowed here, because it is impossible
+  // to ensure non-empty |upload_content| as it may not be initialized yet.
+  DCHECK(!upload_content_type.empty());
+
   upload_content_type_ = upload_content_type;
   upload_content_ = upload_content.Pass();
 }
 
 void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
   DCHECK(is_chunked_upload_ ||
          (upload_content_type_.empty() &&
           !upload_content_));

[mmenke, 2013/02/06 17:27:07]

"DCHECK(!upload_content_type.empty());" here as well

[hidehiko, 2013/02/06 17:55:41]

Done.

   upload_content_type_ = content_type;
   upload_content_.reset();
   is_chunked_upload_ = true;
 }
 
 void URLFetcherCore::AppendChunkToUpload(const std::string& content,
                                          bool is_last_chunk) {
   DCHECK(delegate_task_runner_);
   DCHECK(network_task_runner_.get());
   network_task_runner_->PostTask(
@@ skipping 363 matching lines @@
                           url_request_create_data_callback_.Run());
   }
 
   switch (request_type_) {
     case URLFetcher::GET:
       break;
 
     case URLFetcher::POST:
     case URLFetcher::PUT:
     case URLFetcher::PATCH:
-      DCHECK(!upload_content_type_.empty());
+      // Upload content must be set.
+      DCHECK(is_chunked_upload_ || upload_content_);
 
       request_->set_method(
           request_type_ == URLFetcher::POST ? "POST" :
           request_type_ == URLFetcher::PUT ? "PUT" : "PATCH");
-      extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
-                                       upload_content_type_);
+      if (!upload_content_type_.empty()) {
+        extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
+                                         upload_content_type_);
+      }
       if (upload_content_)
         request_->set_upload(upload_content_.Pass());
       current_upload_bytes_ = -1;
       // TODO(kinaba): http://crbug.com/118103. Implement upload callback in the
       //  layer and avoid using timer here.
       upload_progress_checker_timer_.reset(
           new base::RepeatingTimer<URLFetcherCore>());
       upload_progress_checker_timer_->Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUploadProgressTimerInterval),
@@ skipping 310 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net