Added the ability to set the upload file path

chrome/browser/local_discovery/privet_url_fetcher.cc

 // Copyright 2013 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/local_discovery/privet_url_fetcher.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
+#include "content/public/browser/browser_thread.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
 
 namespace local_discovery {
 
 namespace {
 const char kXPrivetTokenHeaderPrefix[] = "X-Privet-Token: ";
 const char kXPrivetEmptyToken[] = "\"\"";
 const int kPrivetMaxRetries = 20;
 const int kPrivetTimeoutOnError = 5;
@@ skipping 35 matching lines @@
 
     if (token.empty())
       token = kXPrivetEmptyToken;
 
     url_fetcher_.reset(net::URLFetcher::Create(url_, request_type_, this));
     url_fetcher_->SetRequestContext(request_context_);
     url_fetcher_->AddExtraRequestHeader(std::string(kXPrivetTokenHeaderPrefix) +
                                         token);
 
     // URLFetcher requires us to set upload data for POST requests.
-    if (request_type_ == net::URLFetcher::POST)
-      url_fetcher_->SetUploadData(upload_content_type_, upload_data_);
+    if (request_type_ == net::URLFetcher::POST) {
+      if (!upload_file_path_.empty()) {
+        url_fetcher_->SetUploadFilePath(
+            upload_content_type_,
+            upload_file_path_,
+            0 /*offset*/,
+            kuint64max /*length*/,
+            content::BrowserThread::GetMessageLoopProxyForThread(
+                content::BrowserThread::FILE));
+      } else {
+        url_fetcher_->SetUploadData(upload_content_type_, upload_data_);
+      }
+    }
 
     url_fetcher_->Start();
   } else {
     delegate_->OnError(this, RETRY_ERROR);
   }
 }
 
 void PrivetURLFetcher::Start() {
   DCHECK_EQ(tries_, 0);  // We haven't called |Start()| yet.
 
   if (privet_access_token_.empty() && !allow_empty_privet_token_) {
     RequestTokenRefresh();
   } else {
     Try();
   }
 }
 
 void PrivetURLFetcher::SetUploadData(const std::string& upload_content_type,
                                      const std::string& upload_data) {
+  DCHECK(upload_file_path_.empty());
   upload_content_type_ = upload_content_type;
   upload_data_ = upload_data;
 }
 
+void PrivetURLFetcher::SetUploadFilePath(
+    const std::string& upload_content_type,
+    const base::FilePath& upload_file_path) {
+  DCHECK(upload_data_.empty());
+  upload_content_type_ = upload_content_type;
+  upload_file_path_ = upload_file_path;
+}
+
 void PrivetURLFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
   if (source->GetStatus().status() != net::URLRequestStatus::SUCCESS ||
       source->GetResponseCode() == net::HTTP_SERVICE_UNAVAILABLE) {
     ScheduleRetry(kPrivetTimeoutOnError);
     return;
   }
 
   if (source->GetResponseCode() != net::HTTP_OK) {
     delegate_->OnError(this, RESPONSE_CODE_ERROR);
     return;
@@ skipping 90 matching lines @@
 
 scoped_ptr<PrivetURLFetcher> PrivetURLFetcherFactory::CreateURLFetcher(
     const GURL& url, net::URLFetcher::RequestType request_type,
     PrivetURLFetcher::Delegate* delegate) const {
   return scoped_ptr<PrivetURLFetcher>(
       new PrivetURLFetcher(token_, url, request_type, request_context_.get(),
                            delegate));
 }
 
 }  // namespace local_discovery