Implemented upload progress indicator in status bar.

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2009 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 1561 matching lines @@
 // whereas waiting for a host name to resolve implies being stuck.
 //
 net::LoadState MoreInterestingLoadState(net::LoadState a, net::LoadState b) {
   return (a < b) ? b : a;
 }
 
 // Carries information about a load state change.
 struct LoadInfo {
   GURL url;
   net::LoadState load_state;
+  uint64 upload_position;
+  uint64 upload_size;
 };
 
 // Map from ProcessID+ViewID pair to LoadState
 typedef std::map<std::pair<int, int>, LoadInfo> LoadInfoMap;
 
 // Used to marshall calls to LoadStateChanged from the IO to UI threads.  We do
 // them all as a single task to avoid spamming the UI thread.
 class LoadInfoUpdateTask : public Task {
  public:
   virtual void Run() {
     LoadInfoMap::const_iterator i;
     for (i = info_map.begin(); i != info_map.end(); ++i) {
       RenderViewHost* view =
           RenderViewHost::FromID(i->first.first, i->first.second);
       if (view)  // The view could be gone at this point.
-        view->LoadStateChanged(i->second.url, i->second.load_state);
+        view->LoadStateChanged(i->second.url, i->second.load_state,
+                               i->second.upload_position,
+                               i->second.upload_size);
     }
   }
   LoadInfoMap info_map;
 };
 
 }  // namespace
 
 void ResourceDispatcherHost::UpdateLoadStates() {
   // Populate this map with load state changes, and then send them on to the UI
   // thread where they can be passed along to the respective RVHs.
   LoadInfoMap info_map;
 
   PendingRequestList::const_iterator i;
+
+  // Determine the largest upload size of all requests
+  // in each View (good chance it's zero).
+  std::map<std::pair<int, int>, uint64> largest_upload_size;
+  for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
+    URLRequest* request = i->second;
+    ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+    uint64 upload_size = info->upload_size();
+    if (request->GetLoadState() != net::LOAD_STATE_SENDING_REQUEST)
+      upload_size = 0;
+    std::pair<int, int> key(info->child_id(), info->route_id());
+    if (upload_size && largest_upload_size[key] < upload_size)
+      largest_upload_size[key] = upload_size;
+  }
+
   for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
     URLRequest* request = i->second;
     net::LoadState load_state = request->GetLoadState();
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
     // We also poll for upload progress on this timer and send upload
     // progress ipc messages to the plugin process.
-    MaybeUpdateUploadProgress(info, request);
+    bool update_upload_progress = MaybeUpdateUploadProgress(info, request);
 
-    if (info->last_load_state() != load_state) {
+    if (info->last_load_state() != load_state || update_upload_progress) {
+      std::pair<int, int> key(info->child_id(), info->route_id());
+
+      // If a request is uploading data, ignore all other requests so that the
+      // upload progress takes priority for being shown in the status bar.
+      if (largest_upload_size.find(key) != largest_upload_size.end() &&
+          info->upload_size() < largest_upload_size[key])
+        continue;
+
       info->set_last_load_state(load_state);
 
-      std::pair<int, int> key(info->child_id(), info->route_id());
       net::LoadState to_insert;
       LoadInfoMap::iterator existing = info_map.find(key);
       if (existing == info_map.end()) {
         to_insert = load_state;
       } else {
         to_insert =
             MoreInterestingLoadState(existing->second.load_state, load_state);
         if (to_insert == existing->second.load_state)
           continue;
       }
       LoadInfo& load_info = info_map[key];
       load_info.url = request->url();
       load_info.load_state = to_insert;
+      load_info.upload_size = info->upload_size();
+      load_info.upload_position = request->GetUploadProgress();
     }
   }
 
   if (info_map.empty())
     return;
 
   LoadInfoUpdateTask* task = new LoadInfoUpdateTask;
   task->info_map.swap(info_map);
   ui_loop_->PostTask(FROM_HERE, task);
 }
 
-void ResourceDispatcherHost::MaybeUpdateUploadProgress(
+// Calls the ResourceHandler to send upload progress messages to the renderer.
+// Returns true iff an upload progress message should be sent to the UI thread.
+bool ResourceDispatcherHost::MaybeUpdateUploadProgress(
     ResourceDispatcherHostRequestInfo *info,
     URLRequest *request) {
-  if (!info->upload_size() || info->waiting_for_upload_progress_ack() ||
-      !(request->load_flags() & net::LOAD_ENABLE_UPLOAD_PROGRESS))
-    return;
+
+  if (!info->upload_size() || info->waiting_for_upload_progress_ack())
+    return false;
 
   uint64 size = info->upload_size();
   uint64 position = request->GetUploadProgress();
   if (position == info->last_upload_position())
-    return;  // no progress made since last time
+    return false;  // no progress made since last time
 
   const uint64 kHalfPercentIncrements = 200;
   const TimeDelta kOneSecond = TimeDelta::FromMilliseconds(1000);
 
   uint64 amt_since_last = position - info->last_upload_position();
   TimeDelta time_since_last = TimeTicks::Now() - info->last_upload_ticks();
 
   bool is_finished = (size == position);
   bool enough_new_progress = (amt_since_last > (size / kHalfPercentIncrements));
   bool too_much_time_passed = time_since_last > kOneSecond;
 
   if (is_finished || enough_new_progress || too_much_time_passed) {
-    info->resource_handler()->OnUploadProgress(info->request_id(),
-                                               position, size);
-    info->set_waiting_for_upload_progress_ack(true);
+    if (request->load_flags() & net::LOAD_ENABLE_UPLOAD_PROGRESS) {
+      info->resource_handler()->OnUploadProgress(info->request_id(),
+                                                 position, size);
+      info->set_waiting_for_upload_progress_ack(true);
+    }
     info->set_last_upload_ticks(TimeTicks::Now());
     info->set_last_upload_position(position);
+    return true;
   }
+  return false;
 }
 
 void ResourceDispatcherHost::BlockRequestsForRoute(int child_id, int route_id) {
   std::pair<int, int> key(child_id, route_id);
   DCHECK(blocked_requests_map_.find(key) == blocked_requests_map_.end()) <<
       "BlockRequestsForRoute called  multiple time for the same RVH";
   blocked_requests_map_[key] = new BlockedRequestsList();
 }
 
 void ResourceDispatcherHost::ResumeBlockedRequestsForRoute(int child_id,
@@ skipping 52 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }