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

net/url_request/url_request.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.
 
 #include "net/url_request/url_request.h"
 
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 122 matching lines @@
 URLRequest::URLRequest(const GURL& url, Delegate* delegate)
     : url_chain_(1, url),
       method_("GET"),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       redirect_limit_(kMaxRedirects),
       final_upload_progress_(0),
       priority_(LOWEST),
       identifier_(GenerateURLRequestIdentifier()),
+      blocked_on_delegate_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           before_request_callback_(this, &URLRequest::BeforeRequestComplete)),
       has_notified_completion_(false) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
   // Sanity check out environment.
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
@@ skipping 93 matching lines @@
 
 void URLRequest::SetExtraRequestHeaders(
     const HttpRequestHeaders& headers) {
   DCHECK(!is_pending_);
   extra_request_headers_ = headers;
 
   // NOTE: This method will likely become non-trivial once the other setters
   // for request headers are implemented.
 }
 
-LoadState URLRequest::GetLoadState() const {
-  return job_ ? job_->GetLoadState() : LOAD_STATE_IDLE;
+LoadStateWithParam URLRequest::GetLoadState() const {
+  if (blocked_on_delegate_) {
+    return net::LoadStateWithParam(LOAD_STATE_WAITING_FOR_DELEGATE,
+                                   load_state_param_);
+  }
+  return net::LoadStateWithParam(job_ ? job_->GetLoadState() : LOAD_STATE_IDLE,
+                                 "");
 }
 
 uint64 URLRequest::GetUploadProgress() const {
   if (!job_) {
     // We haven't started or the request was cancelled
     return 0;
   }
   if (final_upload_progress_) {
     // The first job completed and none of the subsequent series of
     // GETs when following redirects will upload anything, so we return the
@@ skipping 124 matching lines @@
 }
 
 void URLRequest::Start() {
   response_info_.request_time = Time::Now();
 
   // Only notify the delegate for the initial request.
   if (context_ && context_->network_delegate()) {
     if (context_->network_delegate()->NotifyBeforeURLRequest(
             this, &before_request_callback_, &delegate_redirect_url_) ==
             net::ERR_IO_PENDING) {
-      net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+      SetBlockedOnDelegate();
       return;  // paused
     }
   }
 
   StartJob(URLRequestJobManager::GetInstance()->CreateJob(this));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::BeforeRequestComplete(int error) {
   DCHECK(!job_);
   DCHECK_NE(ERR_IO_PENDING, error);
 
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+  SetUnblockedOnDelegate();
   if (error != OK) {
     net_log_.AddEvent(NetLog::TYPE_CANCELLED,
         make_scoped_refptr(new NetLogStringParameter("source", "delegate")));
     StartJob(new URLRequestErrorJob(this, error));
   } else if (!delegate_redirect_url_.is_empty()) {
     GURL new_url;
     new_url.Swap(&delegate_redirect_url_);
     StartJob(new URLRequestRedirectJob(this, new_url));
   } else {
     StartJob(URLRequestJobManager::GetInstance()->CreateJob(this));
@@ skipping 367 matching lines @@
   // not be needed.
   if (has_notified_completion_)
     return;
 
   is_pending_ = false;
   has_notified_completion_ = true;
   if (context_ && context_->network_delegate())
     context_->network_delegate()->NotifyCompleted(this);
 }
 
+void URLRequest::SetBlockedOnDelegate() {
+  blocked_on_delegate_ = true;
+  net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+}
+
+void URLRequest::SetUnblockedOnDelegate() {
+  blocked_on_delegate_ = false;
+  load_state_param_.clear();
+  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+}
+
 }  // namespace net