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

net/base/load_states.h

 // 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.
 
 #ifndef NET_BASE_LOAD_STATES_H__
 #define NET_BASE_LOAD_STATES_H__
 #pragma once
 
+#include <string>
+
 namespace net {
 
 // These states correspond to the lengthy periods of time that a resource load
 // may be blocked and unable to make progress.
 enum LoadState {
   // This is the default state.  It corresponds to a resource load that has
   // either not yet begun or is idle waiting for the consumer to do something
   // to move things along (e.g., the consumer of an URLRequest may not have
   // called Read yet).
   LOAD_STATE_IDLE,
 
+  // This state indicates that the URLRequest delegate has chosen to block this
+  // request before it was sent over the network. When in this state, the
+  // delegate should set a load state parameter on the URLRequest describing
+  // the nature of the delay (i.e. "Waiting for <description given by
+  // delegate>").
+  LOAD_STATE_WAITING_FOR_DELEGATE,
+
   // This state corresponds to a resource load that is blocked waiting for
   // access to a resource in the cache.  If multiple requests are made for the
   // same resource, the first request will be responsible for writing (or
   // updating) the cache entry and the second request will be deferred until
   // the first completes.  This may be done to optimize for cache reuse.
   LOAD_STATE_WAITING_FOR_CACHE,
 
   // This state corresponds to a resource load that is blocked waiting for a
   // proxy autoconfig script to return a proxy server to use.  This state may
   // take a while if the proxy script needs to resolve the IP address of the
@@ skipping 32 matching lines @@
   LOAD_STATE_WAITING_FOR_RESPONSE,
 
   // This state corresponds to a resource load that is blocked waiting for a
   // read to complete.  In the case of a HTTP transaction, this corresponds to
   // the period after the response headers have been received and before all of
   // the response body has been downloaded.  (NOTE: This state only applies for
   // an URLRequest while there is an outstanding Read operation.)
   LOAD_STATE_READING_RESPONSE,
 };
 
+// Some states, like LOAD_STATE_WAITING_FOR_DELEGATE, are associated with extra
+// data that describes more precisely what the delegate (for example) is doing.
+// This class provides an easy way to hold a load state with an extra parameter.
+struct LoadStateWithParam {
+  LoadState state;
+  std::string param;

[eroman, 2011/08/05 01:54:22]

Can you make this a string16? Seems there are already conversion from UTF16 -->
UTF8 going on, since this is intended for display seems simpler to just keep it
wide.

[Matt Perry, 2011/08/08 22:14:33]

Done.

+  LoadStateWithParam() {}
+  LoadStateWithParam(LoadState state, const std::string& param)
+      : state(state), param(param) {}
+};
+
 }  // namespace net
 
 #endif  // NET_BASE_LOAD_STATES_H__