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

net/url_request/url_request.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_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 411 matching lines @@
 
   // Sets all extra request headers.  Any extra request headers set by other
   // methods are overwritten by this method.  This method may only be called
   // before Start() is called.  It is an error to call it later.
   void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
 
   const HttpRequestHeaders& extra_request_headers() const {
     return extra_request_headers_;
   }
 
-  // Returns the current load state for the request.
-  LoadState GetLoadState() const;
+  // Returns the current load state for the request. |param| is an optional

[willchan no longer on Chromium, 2011/07/29 07:34:38]

I think you're working forward from the assumption that NetworkDelegate implies
extensions, and therefore when we're blocked on the delegate, we must always
want a parameter to attach to the LoadState. I'd argue this is not necessarily
true. There are possible future consumers who won't want this.

Therefore, I think that the network stack client should be storing this. Whoever
is calling GetLoadState() (RDH, right?) should, if the value indicates we're
blocked on the delegate, query the appropriate object (the delegate probably) to
figure out the reason for the blockage, using the URLRequest* as a lookup key.

I guess then we'd need to add a new method to the NetworkDelegate to allow
querying why a URLRequest* is blocked. I'm not sure I really like adding it to
NetworkDelegate since not all consumers need it and it burdens them with an
implementation, but I guess the alternative is unwieldy (having content/
subclass NetworkDelegate to introduce a new interface with a single added
method. I think this is the only alternative since content/ can't directly
depend on ChromeNetworkDelegate/ExtensionWebRequestAPI since those are chrome/
classes). So I guess I'm fine with adding an interface to NetworkDelegate for
this, with a comment indicating we should consider moving it out in the future.

[Matt Perry, 2011/07/29 21:30:49]

Agreed, I took care to avoid this assumption. That's why I made the param
optional. Extensions will use it, but other delegate consumers might not.
Doesn't this suffer from the same problem you point out above? :) Namely, the
assumption that "blocked on NetworkDelegate" implies "there's some string
explaining why".

+  // parameter describing details related to the load state. Not all load states
+  // have a parameter.
+  LoadStateWithParam GetLoadState() const;
+  void SetLoadStateParam(const std::string& param) {
+    load_state_param_ = param;
+  }
 
   // Returns the current upload progress in bytes.
   uint64 GetUploadProgress() const;
 
   // Get response header(s) by ID or name.  These methods may only be called
   // once the delegate's OnResponseStarted method has been called.  Headers
   // that appear more than once in the response are coalesced, with values
   // separated by commas (per RFC 2616). This will not work with cookies since
   // comma can be used in cookie values.
   // TODO(darin): add API to enumerate response headers.
@@ skipping 152 matching lines @@
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
   void ContinueWithCertificate(X509Certificate* client_cert);
 
   // This method can be called after some error notifications to instruct this
   // URLRequest to ignore the current error and continue with the request.  To
   // cancel the request instead, call Cancel().
   void ContinueDespiteLastError();
 
+  // Called when the delegate blocks or unblocks this request when intercepting

[willchan no longer on Chromium, 2011/07/29 07:34:38]

These should be private. I think you made them public for URLRequestHttpJob to
call. I'm trying to tighten the interfaces. Any special interface needed to
access details in URLRequest from a job should be private in URLRequest, and be
protected in URLRequestJob. So URLRequestHttpJob should access these member
functions via its parent's protected member function.

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

Matt, can you address Will's comment? (Note that URLRequest job is friended).

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

Done.

+  // certain requests.
+  void SetBlockedOnDelegate();
+  void SetUnblockedOnDelegate();
+
   // Used to specify the context (cookie store, cache) for this request.
   const URLRequestContext* context() const;
   void set_context(const URLRequestContext* context);
 
   const BoundNetLog& net_log() const { return net_log_; }
 
   // Returns the expected content size if available
   int64 GetExpectedContentSize() const;
 
   // Returns the priority level for this request.
@@ skipping 149 matching lines @@
 
   // TODO(battre): The only consumer of the identifier_ is currently the
   // web request API. We need to match identifiers of requests between the
   // web request API and the web navigation API. As the URLRequest does not
   // exist when the web navigation API is triggered, the tracking probably
   // needs to be done outside of the URLRequest anyway. Therefore, this
   // identifier should be deleted here. http://crbug.com/89321
   // A globally unique identifier for this request.
   const uint64 identifier_;
 
+  // True if this request is blocked waiting for the network delegate to resume
+  // it.
+  bool blocked_on_delegate_;
+
+  // An optional parameter that provides additional information about the load
+  // state. Only used with the LOAD_STATE_WAITING_FOR_DELEGATE state.
+  std::string load_state_param_;
+
   base::debug::LeakTracker<URLRequest> leak_tracker_;
 
   // Callback passed to the network delegate to notify us when a blocked request
   // is ready to be resumed or canceled.
   CompletionCallbackImpl<URLRequest> before_request_callback_;
 
   // Safe-guard to ensure that we do not send multiple "I am completed"
   // messages to network delegate.
   // TODO(battre): Remove this. http://crbug.com/89049
   bool has_notified_completion_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_