Don't share ResourceDispatcherHostImpl's timer for reporting upload progress.

content/browser/loader/resource_loader.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 "content/browser/loader/resource_loader.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 22 matching lines @@
 #include "net/ssl/client_cert_store.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_status.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
+// The interval for calls to ResourceLoader::ReportUploadProgress.
+const int kUploadProgressIntervalMsec = 100;
+
 void PopulateResourceResponse(ResourceRequestInfoImpl* info,
                               net::URLRequest* request,
                               ResourceResponse* response) {
   response->head.request_time = request->request_time();
   response->head.response_time = request->response_time();
   response->head.headers = request->response_headers();
   request->GetCharset(&response->head.charset);
   response->head.content_length = request->GetExpectedContentSize();
   request->GetMimeType(&response->head.mime_type);
   net::HttpResponseInfo response_info = request->response_info();
@@ skipping 79 matching lines @@
   ResourceRequestInfoImpl* info = GetRequestInfo();
   info->set_was_ignored_by_handler(true);
   CancelRequest(false);
 }
 
 void ResourceLoader::CancelWithError(int error_code) {
   CancelRequestInternal(error_code, false);
 }
 
 void ResourceLoader::ReportUploadProgress() {
+  DCHECK(GetRequestInfo()->is_upload_progress_enabled());
+
   if (waiting_for_upload_progress_ack_)
     return;  // Send one progress event at a time.
 
   net::UploadProgress progress = request_->GetUploadProgress();
   if (!progress.size())
     return;  // Nothing to upload.
 
   if (progress.position() == last_upload_position_)
     return;  // No progress made since last time.
 
   const uint64 kHalfPercentIncrements = 200;
   const TimeDelta kOneSecond = TimeDelta::FromMilliseconds(1000);
 
   uint64 amt_since_last = progress.position() - last_upload_position_;
   TimeDelta time_since_last = TimeTicks::Now() - last_upload_ticks_;
 
   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) {
-    ResourceRequestInfoImpl* info = GetRequestInfo();
-    if (info->is_upload_progress_enabled()) {
-      handler_->OnUploadProgress(progress.position(), progress.size());
-      waiting_for_upload_progress_ack_ = true;
-    }
+    handler_->OnUploadProgress(progress.position(), progress.size());
+    waiting_for_upload_progress_ack_ = true;
     last_upload_ticks_ = TimeTicks::Now();
     last_upload_position_ = progress.position();
   }
 }
 
 void ResourceLoader::MarkAsTransferring() {
   CHECK(IsResourceTypeFrame(GetRequestInfo()->GetResourceType()))
       << "Can only transfer for navigations";
   is_transferring_ = true;
 
@@ skipping 148 matching lines @@
   } else if (*defer) {
     deferred_stage_ = DEFERRED_NETWORK_START;
   }
 }
 
 void ResourceLoader::OnResponseStarted(net::URLRequest* unused) {
   DCHECK_EQ(request_.get(), unused);
 
   VLOG(1) << "OnResponseStarted: " << request_->url().spec();
 
+  progress_timer_.Stop();
+
   // The CanLoadPage check should take place after any server redirects have
   // finished, at the point in time that we know a page will commit in the
   // renderer process.
   ResourceRequestInfoImpl* info = GetRequestInfo();
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
   if (!policy->CanLoadPage(info->GetChildID(),
                            request_->url(),
                            info->GetResourceType())) {
     Cancel();
     return;
   }
 
   if (!request_->status().is_success()) {
     ResponseCompleted();
     return;
   }
 
   // We want to send a final upload progress message prior to sending the
   // response complete message even if we're waiting for an ack to to a
   // previous upload progress message.
-  waiting_for_upload_progress_ack_ = false;
-  ReportUploadProgress();
+  if (info->is_upload_progress_enabled()) {
+    waiting_for_upload_progress_ack_ = false;
+    ReportUploadProgress();
+  }
 
   CompleteResponseStarted();
 
   if (is_deferred())
     return;
 
   if (request_->status().is_success())
     StartReading(false);  // Read the first chunk.
   else
     ResponseCompleted();
@@ skipping 119 matching lines @@
 void ResourceLoader::StartRequestInternal() {
   DCHECK(!request_->is_pending());
 
   if (!request_->status().is_success()) {
     return;
   }
 
   request_->Start();
 
   delegate_->DidStartRequest(this);
+
+  if (GetRequestInfo()->is_upload_progress_enabled() &&
+      request_->has_upload()) {
+    progress_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kUploadProgressIntervalMsec),
+        this,
+        &ResourceLoader::ReportUploadProgress);
+  }
 }
 
 void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
   VLOG(1) << "CancelRequestInternal: " << request_->url().spec();
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   // WebKit will send us a cancel for downloads since it no longer handles
   // them.  In this case, ignore the cancel since we handle downloads in the
   // browser.
@@ skipping 244 matching lines @@
       case net::URLRequestStatus::FAILED:
         status = STATUS_UNDEFINED;
         break;
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.Prefetch.Pattern", status, STATUS_MAX);
   }
 }
 
 }  // namespace content