Stop using ScopedAllowIO in content::ResourceDispatcherHostImpl

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 600 matching lines @@
   // Called on the IO thread.
   void MaybeUpdateUploadProgress() {
     // If a redirect is received upload is cancelled in net::URLRequest, we
     // should try to stop the |upload_progress_timer_| timer and return.
     if (!request_->has_upload()) {
       if (upload_progress_timer_.IsRunning())
         upload_progress_timer_.Stop();
       return;
     }
 
-    // GetContentLengthSync() may perform file IO, but it's ok here, as file
-    // IO is not prohibited in IOThread defined in the file.
-    uint64 size = request_->get_upload_mutable()->GetContentLengthSync();
-    uint64 position = request_->GetUploadProgress();
-    if (position == last_upload_position_)
+    const net::UploadProgress progress = request_->GetUploadProgress();

[darin (slow to review), 2012/08/29 22:36:16]

nit: no need for 'const' here

[hashimoto, 2012/08/29 22:48:55]

Done.

+    if (progress.position == last_upload_position_)
       return;  // no progress made since last time
 
     const uint64 kHalfPercentIncrements = 200;
     const base::TimeDelta kOneSecond = base::TimeDelta::FromMilliseconds(1000);
 
-    uint64 amt_since_last = position - last_upload_position_;
+    uint64 amt_since_last = progress.position - last_upload_position_;
     base::TimeDelta time_since_last = base::TimeTicks::Now() -
                                       last_upload_ticks_;
 
-    bool is_finished = (size == position);
-    bool enough_new_progress = (amt_since_last > (size /
+    bool is_finished = (progress.size == progress.position);
+    bool enough_new_progress = (amt_since_last > (progress.size /
                                                   kHalfPercentIncrements));
     bool too_much_time_passed = time_since_last > kOneSecond;
 
     if (is_finished || enough_new_progress || too_much_time_passed) {
       owner_loop_->PostTask(
           FROM_HERE,
-          base::Bind(&RequestProxy::NotifyUploadProgress, this, position,
-                     size));
+          base::Bind(&RequestProxy::NotifyUploadProgress, this,
+                     progress.position, progress.size));
       last_upload_ticks_ = base::TimeTicks::Now();
-      last_upload_position_ = position;
+      last_upload_position_ = progress.position;
     }
   }
 
   void PopulateResponseInfo(net::URLRequest* request,
                             ResourceResponseInfo* info) const {
     info->request_time = request->request_time();
     info->response_time = request->response_time();
     info->headers = request->response_headers();
     request->GetMimeType(&info->mime_type);
     request->GetCharset(&info->charset);
@@ skipping 450 matching lines @@
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }