Bypass the cache for the second or later HttpCache::Transaction...

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/string_util.h"
@@ skipping 344 matching lines @@
       return LOAD_STATE_RESOLVING_HOST;
     case STATE_TCP_CONNECT_COMPLETE:
       return LOAD_STATE_CONNECTING;
     case STATE_WRITE_HEADERS_COMPLETE:
     case STATE_WRITE_BODY_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     case STATE_READ_HEADERS_COMPLETE:
       return LOAD_STATE_WAITING_FOR_RESPONSE;
     case STATE_READ_BODY_COMPLETE:
       return LOAD_STATE_READING_RESPONSE;
+    case STATE_WAITING_FOR_USER_ACTION:
+      return LOAD_STATE_WAITING_FOR_USER_ACTION;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 uint64 HttpNetworkTransaction::GetUploadProgress() const {
   if (!request_body_stream_.get())
     return 0;
 
   return request_body_stream_->position();
@@ skipping 118 matching lines @@
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.drain_body_for_auth_restart",
                           request_, request_->url.spec());
         rv = DoDrainBodyForAuthRestart();
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:
         rv = DoDrainBodyForAuthRestartComplete(rv);
         TRACE_EVENT_END("http.drain_body_for_auth_restart",
                         request_, request_->url.spec());
         break;
+      case STATE_WAITING_FOR_USER_ACTION:
+        // When this transcation is suspended for some error such as invalid SSL
+        // certification, the state becomes STATE_WAITING_FOR_USER_ACTION. You
+        // can check if this transaction is in this state by calling
+        // GetLoadState() and compare with LOAD_STATE_WAITING_FOR_USER_ACTION.
+        break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
-  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
+  } while (rv != ERR_IO_PENDING &&
+           next_state_ != STATE_NONE &&
+           next_state_ != STATE_WAITING_FOR_USER_ACTION);
 
   return rv;
 }
 
 int HttpNetworkTransaction::DoResolveProxy() {
   DCHECK(!pac_request_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (request_->load_flags & LOAD_BYPASS_PROXY) {
@@ skipping 136 matching lines @@
   return connection_.socket()->Connect(&io_callback_);
 }
 
 int HttpNetworkTransaction::DoSSLConnectComplete(int result) {
   if (IsCertificateError(result))
     result = HandleCertificateError(result);
 
   if (result == OK) {
     next_state_ = STATE_WRITE_HEADERS;
   } else {
+    next_state_ = STATE_WAITING_FOR_USER_ACTION;
     result = HandleSSLHandshakeError(result);
   }
   return result;
 }
 
 int HttpNetworkTransaction::DoWriteHeaders() {
   next_state_ = STATE_WRITE_HEADERS_COMPLETE;
 
   // This is constructed lazily (instead of within our Start method), so that
   // we have proxy info available.
@@ skipping 1004 matching lines @@
     host_and_port = proxy_info_.proxy_server().host_and_port();
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     host_and_port = GetHostAndPort(request_->url);
   }
   auth_info->host_and_port = ASCIIToWide(host_and_port);
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net