moved upload progress logic from ResourceLoader to AsyncResourceHandler

content/browser/loader/async_resource_handler.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/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 14 matching lines @@
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/log/net_log.h"
 #include "net/url_request/redirect_info.h"
 
+using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
 static int kBufferSize = 1024 * 512;
 static int kMinAllocationSize = 1024 * 4;
 static int kMaxAllocationSize = 1024 * 32;
+// The interval for calls to ReportUploadProgress.
+static int kUploadProgressIntervalMsec = 10;
 
 void GetNumericArg(const std::string& name, int* result) {
   const std::string& value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name);
   if (!value.empty())
     base::StringToInt(value, result);
 }
 
 void InitializeResourceBufferConstants() {
   static bool did_init = false;
@@ skipping 24 matching lines @@
     ResourceDispatcherHostImpl* rdh)
     : ResourceHandler(request),
       ResourceMessageDelegate(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_first_data_msg_(false),
+      last_upload_position_(0),
+      waiting_for_upload_progress_ack_(false),
       reported_transfer_size_(0) {
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AsyncResourceHandler, message)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_FollowRedirect, OnFollowRedirect)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_DataReceived_ACK, OnDataReceivedACK)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_UploadProgress_ACK, OnUploadProgressACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void AsyncResourceHandler::OnFollowRedirect(int request_id) {
   if (!request()->status().is_success()) {
     DVLOG(1) << "OnFollowRedirect for invalid request";
     return;
   }
 
   ResumeIfDeferred();
 }
 
 void AsyncResourceHandler::OnDataReceivedACK(int request_id) {
   if (pending_data_count_) {
     --pending_data_count_;
 
     buffer_->RecycleLeastRecentlyAllocated();
     if (buffer_->CanAllocate())
       ResumeIfDeferred();
   }
 }
 
-bool AsyncResourceHandler::OnUploadProgress(uint64 position,
-                                            uint64 size) {
-  ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
-    return false;
-  return filter->Send(
-      new ResourceMsg_UploadProgress(GetRequestID(), position, size));
+void AsyncResourceHandler::OnUploadProgressACK(int request_id) {
+  waiting_for_upload_progress_ack_ = false;
+}
+
+void AsyncResourceHandler::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) {
+    ResourceMessageFilter* filter = GetFilter();
+    if (filter) {

[mmenke, 2015/08/27 17:21:28]

A bit unrelated to this CL, but if filter is false, we should just early return.
 Doesn't really matter, but setting waiting_for_upload_progress_ack_ to true
seems really weird, since we never sent the message we claim to be waiting for
in the first place.

Could call progress_timer_.Stop(), too, but I don't think that really matters.

+      filter->Send(
+        new ResourceMsg_UploadProgress(GetRequestID(),
+                                       progress.position(),
+                                       progress.size()));
+    }
+    waiting_for_upload_progress_ack_ = true;
+    last_upload_ticks_ = TimeTicks::Now();
+    last_upload_position_ = progress.position();
+  }
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
     bool* defer) {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   if (!info->filter())
     return false;
 
@@ skipping 19 matching lines @@
 }
 
 bool AsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
                                              bool* defer) {
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
 
+  progress_timer_.Stop();
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   if (!info->filter())
     return false;
 
+  // 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.
+  if (info->is_upload_progress_enabled()) {
+    waiting_for_upload_progress_ack_ = false;
+    ReportUploadProgress();
+  }
+
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(
         request(), info->GetContext(), response, info->filter());
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
 
   const HostZoomMapImpl* host_zoom_map =
       static_cast<const HostZoomMapImpl*>(info->filter()->GetHostZoomMap());
 
@@ skipping 28 matching lines @@
                            request()->response_info().metadata->data() +
                                request()->response_info().metadata->size());
     info->filter()->Send(new ResourceMsg_ReceivedCachedMetadata(GetRequestID(),
                                                                 copy));
   }
 
   return true;
 }
 
 bool AsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+  if (GetRequestInfo()->is_upload_progress_enabled() &&
+      request()->has_upload()) {
+    ReportUploadProgress();
+    progress_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kUploadProgressIntervalMsec),
+        this,
+        &AsyncResourceHandler::ReportUploadProgress);
+  }
   return true;
 }
 
 bool AsyncResourceHandler::OnBeforeNetworkStart(const GURL& url, bool* defer) {
   return true;
 }
 
 bool AsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                       int* buf_size,
                                       int min_size) {
@@ skipping 141 matching lines @@
     request()->LogUnblocked();
     controller()->Resume();
   }
 }
 
 void AsyncResourceHandler::OnDefer() {
   request()->LogBlockedBy("AsyncResourceHandler");
 }
 
 }  // namespace content