Stop using ScopedAllowIO in content::ResourceDispatcherHostImpl

chrome/browser/automation/url_request_automation_job.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/automation/url_request_automation_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 47 matching lines @@
     AutomationResourceMessageFilter* filter,
     bool is_pending)
     : net::URLRequestJob(request, network_delegate),
       id_(0),
       tab_(tab),
       message_filter_(filter),
       pending_buf_size_(0),
       redirect_status_(0),
       request_id_(request_id),
       is_pending_(is_pending),
+      upload_size_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DVLOG(1) << "URLRequestAutomationJob create. Count: " << ++instance_count_;
   DCHECK(message_filter_ != NULL);
 
   if (message_filter_) {
     id_ = message_filter_->NewAutomationRequestId();
     DCHECK_NE(id_, 0);
   }
 }
 
@@ skipping 147 matching lines @@
 bool URLRequestAutomationJob::IsRedirectResponse(
     GURL* location, int* http_status_code) {
   if (!net::HttpResponseHeaders::IsRedirectResponseCode(redirect_status_))
     return false;
 
   *http_status_code = redirect_status_;
   *location = GURL(redirect_url_);
   return true;
 }
 
-uint64 URLRequestAutomationJob::GetUploadProgress() const {
+net::UploadProgress URLRequestAutomationJob::GetUploadProgress() const {
+  uint64 progress = 0;
   if (request_ && request_->status().is_success()) {
     // We don't support incremental progress notifications in ChromeFrame. When
     // we receive a response for the POST request from Chromeframe, it means
     // that the upload is fully complete.
-    const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
-    if (info) {
-      return info->GetUploadSize();
-    }
+    progress = upload_size_;
   }
-  return 0;
+  return net::UploadProgress(progress, upload_size_);
 }
 
 net::HostPortPair URLRequestAutomationJob::GetSocketAddress() const {
   return socket_address_;
 }
 
 bool URLRequestAutomationJob::MayFilterMessage(const IPC::Message& message,
                                                int* request_id) {
   switch (message.type()) {
     case AutomationMsg_RequestStarted::ID:
@@ skipping 42 matching lines @@
   redirect_status_ = response.redirect_status;
   DCHECK(redirect_status_ == 0 || redirect_status_ == 200 ||
          (redirect_status_ >= 300 && redirect_status_ < 400));
 
   if (!response.headers.empty()) {
     headers_ = new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(response.headers.data(),
                                           response.headers.size()));
   }
   socket_address_ = response.socket_address;
+  upload_size_ = response.upload_size;
   NotifyHeadersComplete();
 }
 
 void URLRequestAutomationJob::OnDataAvailable(
     int id, const std::string& bytes) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - data available, Size: " << bytes.size();
   DCHECK(!bytes.empty());
 
   // The request completed, and we have all the data.
@@ skipping 170 matching lines @@
   if (!is_done()) {
     NotifyDone(request_status_);
   }
   // Reset any pending reads.
   if (pending_buf_) {
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
     NotifyReadComplete(0);
   }
 }