Add a status message "Waiting for extension Foo..." when there's a request

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 1812 matching lines @@
 // in the order in which they occur during the lifetime of a request, so we can
 // regard states with larger numeric values as being further along toward
 // completion.  We regard those states as more interesting to report since they
 // represent progress.
 //
 // For example, by this measure "tranferring data" is a more interesting state
 // than "resolving host" because when we are transferring data we are actually
 // doing something that corresponds to changes that the user might observe,
 // 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;
+const net::LoadStateWithParam& MoreInterestingLoadState(
+    const net::LoadStateWithParam& a, const net::LoadStateWithParam& b) {
+  return (a.state < b.state) ? b : a;
 }
 
 // Carries information about a load state change.
 struct LoadInfo {
   GURL url;
-  net::LoadState load_state;
+  net::LoadStateWithParam 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 {
@@ skipping 21 matching lines @@
 
   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) {
     net::URLRequest* request = i->second;
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
     uint64 upload_size = info->upload_size();
-    if (request->GetLoadState() != net::LOAD_STATE_SENDING_REQUEST)
+    if (request->GetLoadState().state != 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) {
     net::URLRequest* request = i->second;
-    net::LoadState load_state = request->GetLoadState();
+    net::LoadStateWithParam load_state = request->GetLoadState();
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+    std::pair<int, int> key(info->child_id(), info->route_id());
 
     // We also poll for upload progress on this timer and send upload
     // progress ipc messages to the plugin process.
-    bool update_upload_progress = MaybeUpdateUploadProgress(info, request);
+    MaybeUpdateUploadProgress(info, request);
 
-    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;
 
-      // 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])
+    net::LoadStateWithParam to_insert = load_state;
+    LoadInfoMap::iterator existing = info_map.find(key);
+    if (existing != info_map.end()) {
+      to_insert =
+          MoreInterestingLoadState(existing->second.load_state, load_state);
+      if (to_insert.state == existing->second.load_state.state)
         continue;
-
-      info->set_last_load_state(load_state);
-
-      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();
     }
+    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);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, task);
 }
 
 // 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(
+void ResourceDispatcherHost::MaybeUpdateUploadProgress(
     ResourceDispatcherHostRequestInfo *info,
     net::URLRequest *request) {
 
   if (!info->upload_size() || info->waiting_for_upload_progress_ack())
-    return false;
+    return;
 
   uint64 size = info->upload_size();
   uint64 position = request->GetUploadProgress();
   if (position == info->last_upload_position())
-    return false;  // no progress made since last time
+    return;  // 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) {
     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 145 matching lines @@
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }