---

前面我們分析到，在URLRequestHttpJob::StartTransactionInternal()中，會通過URLRequestContext的HttpTransactionFactory創建HttpTransaction，在URLRequestContextBuilder::Build()中創建HttpTransactionFactory的過程如下：

storage->set_http_network_session(base::WrapUnique(new HttpNetworkSession(network_session_params)));std::unique_ptr<HttpTransactionFactory> http_transaction_factory;if (http_cache_enabled_) {std::unique_ptr<HttpCache::BackendFactory> http_cache_backend;if (http_cache_params_.type != HttpCacheParams::IN_MEMORY) {BackendType backend_type =http_cache_params_.type == HttpCacheParams::DISK? CACHE_BACKEND_DEFAULT: CACHE_BACKEND_SIMPLE;http_cache_backend.reset(new HttpCache::DefaultBackend(DISK_CACHE, backend_type, http_cache_params_.path,http_cache_params_.max_size, context->GetFileTaskRunner()));} else {http_cache_backend =HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);}LOG(INFO) << "Cache is enabled, to create HttpCache";http_transaction_factory.reset(new HttpCache(storage->http_network_session(), std::move(http_cache_backend), true));} else {LOG(INFO) << "Cache is disabled, to create HttpNetworkLayer";http_transaction_factory.reset(new HttpNetworkLayer(storage->http_network_session()));}storage->set_http_transaction_factory(std::move(http_transaction_factory));

Chromium net中有兩個HttpTransactionFactory的實現，分別是HttpCache和HttpNetworkLayer，它們分別在cache被打開和被關閉時用到。這里還會創建HttpNetworkSession。而在cache打開時，在創建HttpCache的同時，還會為它創建http_cache_backend。

HttpCache的創建過程(chromium_android/src/net/http/http_cache.cc)如下：

//----------------------------------------------------------------------------- HttpCache::HttpCache(HttpNetworkSession* session,std::unique_ptr<BackendFactory> backend_factory,bool set_up_quic_server_info): HttpCache(base::WrapUnique(new HttpNetworkLayer(session)),std::move(backend_factory),set_up_quic_server_info) {}HttpCache::HttpCache(std::unique_ptr<HttpTransactionFactory> network_layer,std::unique_ptr<BackendFactory> backend_factory,bool set_up_quic_server_info): net_log_(nullptr),backend_factory_(std::move(backend_factory)),building_backend_(false),bypass_lock_for_test_(false),fail_conditionalization_for_test_(false),mode_(NORMAL),network_layer_(std::move(network_layer)),clock_(new base::DefaultClock()),weak_factory_(this) {HttpNetworkSession* session = network_layer_->GetSession();// Session may be NULL in unittests.// TODO(mmenke): Seems like tests could be changed to provide a session,// rather than having logic only used in unit tests here.if (session) {net_log_ = session->net_log();if (set_up_quic_server_info &&!session->quic_stream_factory()->has_quic_server_info_factory()) {// QuicStreamFactory takes ownership of QuicServerInfoFactoryAdaptor.session->quic_stream_factory()->set_quic_server_info_factory(new QuicServerInfoFactoryAdaptor(this));}} }

這里還是會創建HttpNetworkLayer。HttpTransactionFactory相關的幾個類之間的關系如下：

HttpTransactionFactory

HttpNetworkTransaction表示一個直接的網絡事務，可以理解為一個網絡連接。HttpNetworkSession用于管理網絡連接。HttpNetworkLayer主要用于創建HttpNetworkTransaction。HttpCache和HttpCache::Transaction用于處理緩存。HttpCache::Transaction表示一個啟用了緩存的網絡事務，它會借助于HttpCache保存的HttpNetworkLayer引用創建HttpNetworkTransaction，借助于HttpNetworkTransaction訪問網絡，并根據需要將結果緩存起來。HttpCache則對緩存進行管理。HttpNetworkLayer和HttpCache都是HttpTransactionFactory，而HttpNetworkTransaction和HttpCache::Transaction都是HttpTransaction。

我們先不關心啟用cache時，HTTP請求的處理流程，來看HttpNetworkLayer。則在URLRequestHttpJob::StartTransactionInternal()中將通過HttpNetworkLayer創建類型為HttpNetworkTransaction的HttpTransaction：

HttpNetworkLayer::HttpNetworkLayer(HttpNetworkSession* session): session_(session),suspended_(false) {DCHECK(session_); #if defined(OS_WIN)base::PowerMonitor* power_monitor = base::PowerMonitor::Get();if (power_monitor)power_monitor->AddObserver(this); #endif }HttpNetworkLayer::~HttpNetworkLayer() { #if defined(OS_WIN)base::PowerMonitor* power_monitor = base::PowerMonitor::Get();if (power_monitor)power_monitor->RemoveObserver(this); #endif }int HttpNetworkLayer::CreateTransaction(RequestPriority priority,std::unique_ptr<HttpTransaction>* trans) {if (suspended_)return ERR_NETWORK_IO_SUSPENDED;trans->reset(new HttpNetworkTransaction(priority, GetSession()));return OK; }HttpCache* HttpNetworkLayer::GetCache() {return NULL; }HttpNetworkSession* HttpNetworkLayer::GetSession() {return session_; }void HttpNetworkLayer::OnSuspend() {suspended_ = true;session_->CloseIdleConnections(); }void HttpNetworkLayer::OnResume() {suspended_ = false; }

URLRequestHttpJob::StartTransactionInternal()創建了HttpTransaction之后，它會執行HttpTransaction的Start()來啟動對HTTP事務的處理，HttpNetworkTransaction的Start()定義如下：

int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,const CompletionCallback& callback,const BoundNetLog& net_log) {net_log_ = net_log;request_ = request_info;// Now that we have an HttpRequestInfo object, update server_ssl_config_.session_->GetSSLConfig(*request_, &server_ssl_config_, &proxy_ssl_config_);if (request_->load_flags & LOAD_DISABLE_CERT_REVOCATION_CHECKING) {server_ssl_config_.rev_checking_enabled = false;proxy_ssl_config_.rev_checking_enabled = false;}if (request_->load_flags & LOAD_PREFETCH)response_.unused_since_prefetch = true;next_state_ = STATE_NOTIFY_BEFORE_CREATE_STREAM;int rv = DoLoop(OK);if (rv == ERR_IO_PENDING)callback_ = callback;return rv; }

Chromium net將所有HTTP請求的處理抽象為幾個步驟，并通過一個循環DoLoop()來一步一步地執行。DoLoop()的定義 (chromium_android/src/net/http/http_network_transaction.cc) 如下：

int HttpNetworkTransaction::DoLoop(int result) {DCHECK(next_state_ != STATE_NONE);int rv = result;do {State state = next_state_;next_state_ = STATE_NONE;switch (state) {case STATE_NOTIFY_BEFORE_CREATE_STREAM:DCHECK_EQ(OK, rv);rv = DoNotifyBeforeCreateStream();break;case STATE_CREATE_STREAM:DCHECK_EQ(OK, rv);rv = DoCreateStream();break;case STATE_CREATE_STREAM_COMPLETE:rv = DoCreateStreamComplete(rv);break;case STATE_INIT_STREAM:DCHECK_EQ(OK, rv);rv = DoInitStream();break;case STATE_INIT_STREAM_COMPLETE:rv = DoInitStreamComplete(rv);break;case STATE_GENERATE_PROXY_AUTH_TOKEN:DCHECK_EQ(OK, rv);rv = DoGenerateProxyAuthToken();break;case STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE:rv = DoGenerateProxyAuthTokenComplete(rv);break;case STATE_GENERATE_SERVER_AUTH_TOKEN:DCHECK_EQ(OK, rv);rv = DoGenerateServerAuthToken();break;case STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE:rv = DoGenerateServerAuthTokenComplete(rv);break;case STATE_GET_PROVIDED_TOKEN_BINDING_KEY:DCHECK_EQ(OK, rv);rv = DoGetProvidedTokenBindingKey();break;case STATE_GET_PROVIDED_TOKEN_BINDING_KEY_COMPLETE:rv = DoGetProvidedTokenBindingKeyComplete(rv);break;case STATE_GET_REFERRED_TOKEN_BINDING_KEY:DCHECK_EQ(OK, rv);rv = DoGetReferredTokenBindingKey();break;case STATE_GET_REFERRED_TOKEN_BINDING_KEY_COMPLETE:rv = DoGetReferredTokenBindingKeyComplete(rv);break;case STATE_INIT_REQUEST_BODY:DCHECK_EQ(OK, rv);rv = DoInitRequestBody();break;case STATE_INIT_REQUEST_BODY_COMPLETE:rv = DoInitRequestBodyComplete(rv);break;case STATE_BUILD_REQUEST:DCHECK_EQ(OK, rv);net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);rv = DoBuildRequest();break;case STATE_BUILD_REQUEST_COMPLETE:rv = DoBuildRequestComplete(rv);break;case STATE_SEND_REQUEST:DCHECK_EQ(OK, rv);rv = DoSendRequest();break;case STATE_SEND_REQUEST_COMPLETE:rv = DoSendRequestComplete(rv);net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST, rv);break;case STATE_READ_HEADERS:DCHECK_EQ(OK, rv);net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);rv = DoReadHeaders();break;case STATE_READ_HEADERS_COMPLETE:rv = DoReadHeadersComplete(rv);net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS, rv);break;case STATE_READ_BODY:DCHECK_EQ(OK, rv);net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY);rv = DoReadBody();break;case STATE_READ_BODY_COMPLETE:rv = DoReadBodyComplete(rv);net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY, rv);break;case STATE_DRAIN_BODY_FOR_AUTH_RESTART:DCHECK_EQ(OK, rv);net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);rv = DoDrainBodyForAuthRestart();break;case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:rv = DoDrainBodyForAuthRestartComplete(rv);net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART, rv);break;default:NOTREACHED() << "bad state";rv = ERR_FAILED;break;}} while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);return rv; }

接下來我們逐個地分析這些步驟。

Stream的創建

DoNotifyBeforeCreateStream()執行before_network_start_callback：

int HttpNetworkTransaction::DoNotifyBeforeCreateStream() {next_state_ = STATE_CREATE_STREAM;bool defer = false;if (!before_network_start_callback_.is_null())before_network_start_callback_.Run(&defer);if (!defer)return OK;return ERR_IO_PENDING; }

在DoCreateStream()中創建Stream：

int HttpNetworkTransaction::DoCreateStream() {// TODO(mmenke): Remove ScopedTracker below once crbug.com/424359 is fixed.tracked_objects::ScopedTracker tracking_profile(FROM_HERE_WITH_EXPLICIT_FUNCTION("424359 HttpNetworkTransaction::DoCreateStream"));response_.network_accessed = true;next_state_ = STATE_CREATE_STREAM_COMPLETE;if (ForWebSocketHandshake()) {stream_request_.reset(session_->http_stream_factory_for_websocket()->RequestWebSocketHandshakeStream(*request_,priority_,server_ssl_config_,proxy_ssl_config_,this,websocket_handshake_stream_base_create_helper_,net_log_));} else {stream_request_.reset(session_->http_stream_factory()->RequestStream(*request_,priority_,server_ssl_config_,proxy_ssl_config_,this,net_log_));}DCHECK(stream_request_.get());return ERR_IO_PENDING; }......bool HttpNetworkTransaction::ForWebSocketHandshake() const {return websocket_handshake_stream_base_create_helper_ &&request_->url.SchemeIsWSOrWSS(); }

當請求是一個Websocket請求時，通過HttpNetworkSession的http_stream_factory_for_websocket創建Stream，而其他情況下，則會通過HttpNetworkSession的http_stream_factory創建Stream。

由HttpNetworkSession的創建過程 (chromium_android/src/net/http/http_network_session.cc) 可以看到，http_stream_factory_for_websocket和http_stream_factory都是HttpStreamFactoryImpl：

http_stream_factory_(new HttpStreamFactoryImpl(this, false)),http_stream_factory_for_websocket_(new HttpStreamFactoryImpl(this, true)),

為Websocket之外的其它請求創建Stream的過程 (chromium_android/src/net/http/http_stream_factory_impl.cc) 為：

HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,bool for_websockets): session_(session),job_factory_(new DefaultJobFactory()),for_websockets_(for_websockets) {}HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HttpStreamRequest::Delegate* delegate,const BoundNetLog& net_log) {DCHECK(!for_websockets_);return RequestStreamInternal(request_info, priority, server_ssl_config,proxy_ssl_config, delegate, nullptr,HttpStreamRequest::HTTP_STREAM, net_log); }......HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal(const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HttpStreamRequest::Delegate* delegate,WebSocketHandshakeStreamBase::CreateHelper*websocket_handshake_stream_create_helper,HttpStreamRequest::StreamType stream_type,const BoundNetLog& net_log) {JobController* job_controller =new JobController(this, delegate, session_, job_factory_.get());job_controller_set_.insert(base::WrapUnique(job_controller));Request* request = job_controller->Start(request_info, delegate, websocket_handshake_stream_create_helper, net_log,stream_type, priority, server_ssl_config, proxy_ssl_config);return request; }

在HttpStreamFactoryImpl::RequestStreamInternal()中，主要是創建了一個JobController，然后用job_controller->Start()創建了Request，也就是HttpStreamRequest。

由HttpStreamFactoryImpl的構造函數可以看到，job_factory_是DefaultJobFactory，這個類的實現也相當簡單(chromium_android/src/net/http/http_stream_factory_impl.cc) ：

namespace { // Default JobFactory for creating HttpStreamFactoryImpl::Jobs. class DefaultJobFactory : public HttpStreamFactoryImpl::JobFactory {public:DefaultJobFactory() {}~DefaultJobFactory() override {}HttpStreamFactoryImpl::Job* CreateJob(HttpStreamFactoryImpl::Job::Delegate* delegate,HttpStreamFactoryImpl::JobType job_type,HttpNetworkSession* session,const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HostPortPair destination,GURL origin_url,NetLog* net_log) override {return new HttpStreamFactoryImpl::Job(delegate, job_type, session, request_info, priority, server_ssl_config,proxy_ssl_config, destination, origin_url, net_log);}HttpStreamFactoryImpl::Job* CreateJob(HttpStreamFactoryImpl::Job::Delegate* delegate,HttpStreamFactoryImpl::JobType job_type,HttpNetworkSession* session,const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HostPortPair destination,GURL origin_url,AlternativeService alternative_service,NetLog* net_log) override {return new HttpStreamFactoryImpl::Job(delegate, job_type, session, request_info, priority, server_ssl_config,proxy_ssl_config, destination, origin_url, alternative_service,net_log);} }; } // anonymous namespace

JobController的Start()定義 (chromium_android/src/net/http/http_stream_factory_impl_job_controller.cc) 如下：

HttpStreamFactoryImpl::Request* HttpStreamFactoryImpl::JobController::Start(const HttpRequestInfo& request_info,HttpStreamRequest::Delegate* delegate,WebSocketHandshakeStreamBase::CreateHelper*websocket_handshake_stream_create_helper,const BoundNetLog& net_log,HttpStreamRequest::StreamType stream_type,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config) {DCHECK(factory_);DCHECK(!request_);request_ = new Request(request_info.url, this, delegate,websocket_handshake_stream_create_helper, net_log,stream_type);CreateJobs(request_info, priority, server_ssl_config, proxy_ssl_config,delegate, stream_type, net_log);return request_; }

在這里主要是創建了一個Request，然后調用CreateJobs()創建了一些Jobs：

void HttpStreamFactoryImpl::JobController::CreateJobs(const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HttpStreamRequest::Delegate* delegate,HttpStreamRequest::StreamType stream_type,const BoundNetLog& net_log) {DCHECK(!main_job_);DCHECK(!alternative_job_);HostPortPair destination(HostPortPair::FromURL(request_info.url));GURL origin_url = ApplyHostMappingRules(request_info.url, &destination);main_job_.reset(job_factory_->CreateJob(this, MAIN, session_, request_info, priority, server_ssl_config,proxy_ssl_config, destination, origin_url, net_log.net_log()));AttachJob(main_job_.get());// Create an alternative job if alternative service is set up for this domain.const AlternativeService alternative_service =GetAlternativeServiceFor(request_info, delegate, stream_type);if (alternative_service.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {// Never share connection with other jobs for FTP requests.DVLOG(1) << "Selected alternative service (host: "<< alternative_service.host_port_pair().host()<< " port: " << alternative_service.host_port_pair().port() << ")";DCHECK(!request_info.url.SchemeIs("ftp"));HostPortPair alternative_destination(alternative_service.host_port_pair());ignore_result(ApplyHostMappingRules(request_info.url, &alternative_destination));alternative_job_.reset(job_factory_->CreateJob(this, ALTERNATIVE, session_, request_info, priority, server_ssl_config,proxy_ssl_config, alternative_destination, origin_url,alternative_service, net_log.net_log()));AttachJob(alternative_job_.get());main_job_is_blocked_ = true;alternative_job_->Start(request_->stream_type());}// Even if |alternative_job| has already finished, it will not have notified// the request yet, since we defer that to the next iteration of the// MessageLoop, so starting |main_job_| is always safe.main_job_->Start(request_->stream_type()); }......GURL HttpStreamFactoryImpl::JobController::ApplyHostMappingRules(const GURL& url,HostPortPair* endpoint) {const HostMappingRules* mapping_rules = session_->params().host_mapping_rules;if (mapping_rules && mapping_rules->RewriteHost(endpoint)) {url::Replacements<char> replacements;const std::string port_str = base::UintToString(endpoint->port());replacements.SetPort(port_str.c_str(), url::Component(0, port_str.size()));replacements.SetHost(endpoint->host().c_str(),url::Component(0, endpoint->host().size()));return url.ReplaceComponents(replacements);}return url; }

這里的過程如下：

應用主機映射規則，對url做修飾。

通過job_factory創建main_job。

查找備選服務。

找到了備選服務，則創建alternative_job，并Start它。

Start main_job。

我們前面提到的一些Jobs主要是指main_job，和可能會創建的alternative_job。

接著我們來看Job的Start()方法(chromium_android/src/net/http/http_stream_factory_impl_job.cc) ：

void HttpStreamFactoryImpl::Job::Start(HttpStreamRequest::StreamType stream_type) {stream_type_ = stream_type;StartInternal(); }.......int HttpStreamFactoryImpl::Job::RunLoop(int result) {TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),"HttpStreamFactoryImpl::Job::RunLoop");LOG(INFO) << "HttpStreamFactoryImpl Job DoLoop start " << "job type " << job_type_;result = DoLoop(result);LOG(INFO) << "HttpStreamFactoryImpl Job DoLoop end " << "result " << result;if (result == ERR_IO_PENDING)return result;if (job_type_ == PRECONNECT) {base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&HttpStreamFactoryImpl::Job::OnPreconnectsComplete,ptr_factory_.GetWeakPtr()));return ERR_IO_PENDING;}if (IsCertificateError(result)) {// Retrieve SSL information from the socket.GetSSLInfo();next_state_ = STATE_WAITING_USER_ACTION;base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&HttpStreamFactoryImpl::Job::OnCertificateErrorCallback,ptr_factory_.GetWeakPtr(), result, ssl_info_));return ERR_IO_PENDING;}switch (result) {case ERR_PROXY_AUTH_REQUESTED: {UMA_HISTOGRAM_BOOLEAN("Net.ProxyAuthRequested.HasConnection",connection_.get() != NULL);if (!connection_.get())return ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION;CHECK(connection_->socket());CHECK(establishing_tunnel_);next_state_ = STATE_WAITING_USER_ACTION;ProxyClientSocket* proxy_socket =static_cast<ProxyClientSocket*>(connection_->socket());base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&Job::OnNeedsProxyAuthCallback, ptr_factory_.GetWeakPtr(),*proxy_socket->GetConnectResponseInfo(),base::RetainedRef(proxy_socket->GetAuthController())));return ERR_IO_PENDING;}case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&Job::OnNeedsClientAuthCallback, ptr_factory_.GetWeakPtr(),base::RetainedRef(connection_->ssl_error_response_info().cert_request_info)));return ERR_IO_PENDING;case ERR_HTTPS_PROXY_TUNNEL_RESPONSE: {DCHECK(connection_.get());DCHECK(connection_->socket());DCHECK(establishing_tunnel_);ProxyClientSocket* proxy_socket =static_cast<ProxyClientSocket*>(connection_->socket());base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(&Job::OnHttpsProxyTunnelResponseCallback,ptr_factory_.GetWeakPtr(),*proxy_socket->GetConnectResponseInfo(),proxy_socket->CreateConnectResponseStream()));return ERR_IO_PENDING;}case OK:job_status_ = STATUS_SUCCEEDED;MaybeMarkAlternativeServiceBroken();next_state_ = STATE_DONE;if (new_spdy_session_.get()) {base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(&Job::OnNewSpdySessionReadyCallback,ptr_factory_.GetWeakPtr()));} else if (delegate_->for_websockets()) {DCHECK(websocket_stream_);base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(&Job::OnWebSocketHandshakeStreamReadyCallback,ptr_factory_.GetWeakPtr()));} else if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {if (!bidirectional_stream_impl_) {base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(&Job::OnStreamFailedCallback,ptr_factory_.GetWeakPtr(), ERR_FAILED));} else {base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&Job::OnBidirectionalStreamImplReadyCallback,ptr_factory_.GetWeakPtr()));}} else {DCHECK(stream_.get());job_stream_ready_start_time_ = base::TimeTicks::Now();base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));}return ERR_IO_PENDING;default:if (job_status_ != STATUS_BROKEN) {DCHECK_EQ(STATUS_RUNNING, job_status_);job_status_ = STATUS_FAILED;MaybeMarkAlternativeServiceBroken();}base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(&Job::OnStreamFailedCallback,ptr_factory_.GetWeakPtr(), result));return ERR_IO_PENDING;} }......int HttpStreamFactoryImpl::Job::StartInternal() {CHECK_EQ(STATE_NONE, next_state_);next_state_ = STATE_START;int rv = RunLoop(OK);DCHECK_EQ(ERR_IO_PENDING, rv);return rv; }

執行調用流程大體如下：

HttpStreamFactoryImpl_Job

在HttpStreamFactoryImpl::Job::RunLoop()中，主要是調用了HttpStreamFactoryImpl::Job::DoLoop()，并針對其執行結果，調用響應的回調函數，如：

void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {DCHECK_NE(job_type_, PRECONNECT);MaybeCopyConnectionAttemptsFromSocketOrHandle();delegate_->OnStreamFailed(this, result, server_ssl_config_);// |this| may be deleted after this call. }void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(int result, const SSLInfo& ssl_info) {DCHECK_NE(job_type_, PRECONNECT);MaybeCopyConnectionAttemptsFromSocketOrHandle();delegate_->OnCertificateError(this, result, server_ssl_config_, ssl_info);// |this| may be deleted after this call. }

從前面的HttpStreamFactoryImpl::JobController::CreateJobs()中可以看到，delegate_正是HttpStreamFactoryImpl::JobController。

而在HttpStreamFactoryImpl::Job::DoLoop()中，則是處理Stream建立的事情。與HttpNetworkTransaction的 Start() 執行的DoLoop()類似，HttpStreamFactoryImpl::Job::DoLoop()也是將Stream創建的過程抽象為一系列的步驟，通過一個循環，以一種類似于狀態機模式的方式逐步驟執行：

int HttpStreamFactoryImpl::Job::DoLoop(int result) {DCHECK_NE(next_state_, STATE_NONE);int rv = result;do {State state = next_state_;next_state_ = STATE_NONE;switch (state) {case STATE_START:DCHECK_EQ(OK, rv);rv = DoStart();break;case STATE_RESOLVE_PROXY:DCHECK_EQ(OK, rv);rv = DoResolveProxy();break;case STATE_RESOLVE_PROXY_COMPLETE:rv = DoResolveProxyComplete(rv);break;case STATE_WAIT:DCHECK_EQ(OK, rv);rv = DoWait();break;case STATE_WAIT_COMPLETE:rv = DoWaitComplete(rv);break;case STATE_INIT_CONNECTION:DCHECK_EQ(OK, rv);rv = DoInitConnection();break;case STATE_INIT_CONNECTION_COMPLETE:rv = DoInitConnectionComplete(rv);break;case STATE_WAITING_USER_ACTION:rv = DoWaitingUserAction(rv);break;case STATE_RESTART_TUNNEL_AUTH:DCHECK_EQ(OK, rv);rv = DoRestartTunnelAuth();break;case STATE_RESTART_TUNNEL_AUTH_COMPLETE:rv = DoRestartTunnelAuthComplete(rv);break;case STATE_CREATE_STREAM:DCHECK_EQ(OK, rv);rv = DoCreateStream();break;case STATE_CREATE_STREAM_COMPLETE:rv = DoCreateStreamComplete(rv);break;default:NOTREACHED() << "bad state";rv = ERR_FAILED;break;}} while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);return rv; }

以執行一個QUIC請求為例，創建Stream的整個執行流程大體如下：

CreateStream

備選服務機制

在HttpStreamFactoryImpl::JobController的CreateJobs()中我們看到，在通過job_factory創建main_job之后，會查找備選服務，在找到了備選服務時，還會為它創建job，并Start。那備選服務又是一套什么樣的機制呢？

我們從兩個方面來探究這套機制究竟是什么樣的，及它又被用來做什么，一是備選服務的信息是從哪里及如何獲取的，二是備選服務對HttpStreamFactoryImpl::Job::Job的操作的影響。

獲取備選服務信息

我們先來看備選服務信息的獲取。在HttpStreamFactoryImpl::JobController的CreateJobs()中，通過GetAlternativeServiceFor()來獲取備選服務的信息：

AlternativeService HttpStreamFactoryImpl::JobController::GetAlternativeServiceFor(const HttpRequestInfo& request_info,HttpStreamRequest::Delegate* delegate,HttpStreamRequest::StreamType stream_type) {AlternativeService alternative_service =GetAlternativeServiceForInternal(request_info, delegate, stream_type);AlternativeServiceType type;if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {type = NO_ALTERNATIVE_SERVICE;} else if (alternative_service.protocol == QUIC) {if (request_info.url.host() == alternative_service.host) {type = QUIC_SAME_DESTINATION;} else {type = QUIC_DIFFERENT_DESTINATION;}} else {if (request_info.url.host() == alternative_service.host) {type = NOT_QUIC_SAME_DESTINATION;} else {type = NOT_QUIC_DIFFERENT_DESTINATION;}}UMA_HISTOGRAM_ENUMERATION("Net.AlternativeServiceTypeForRequest", type,MAX_ALTERNATIVE_SERVICE_TYPE);return alternative_service; }

這里主要通過GetAlternativeServiceForInternal()獲取備選服務的信息：

AlternativeService HttpStreamFactoryImpl::JobController::GetAlternativeServiceForInternal(const HttpRequestInfo& request_info,HttpStreamRequest::Delegate* delegate,HttpStreamRequest::StreamType stream_type) {GURL original_url = request_info.url;if (!original_url.SchemeIs("https"))return AlternativeService();url::SchemeHostPort origin(original_url);HttpServerProperties& http_server_properties =*session_->http_server_properties();const AlternativeServiceVector alternative_service_vector =http_server_properties.GetAlternativeServices(origin);if (alternative_service_vector.empty())return AlternativeService();bool quic_advertised = false;bool quic_all_broken = true;// First Alt-Svc that is not marked as broken.AlternativeService first_alternative_service;for (const AlternativeService& alternative_service :alternative_service_vector) {DCHECK(IsAlternateProtocolValid(alternative_service.protocol));if (!quic_advertised && alternative_service.protocol == QUIC)quic_advertised = true;if (http_server_properties.IsAlternativeServiceBroken(alternative_service)) {HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN);continue;}// Some shared unix systems may have user home directories (like// http://foo.com/~mike) which allow users to emit headers. This is a bad// idea already, but with Alternate-Protocol, it provides the ability for a// single user on a multi-user system to hijack the alternate protocol.// These systems also enforce ports <1024 as restricted ports. So don't// allow protocol upgrades to user-controllable ports.const int kUnrestrictedPort = 1024;if (!session_->params().enable_user_alternate_protocol_ports &&(alternative_service.port >= kUnrestrictedPort &&origin.port() < kUnrestrictedPort))continue;if (alternative_service.protocol >= NPN_SPDY_MINIMUM_VERSION &&alternative_service.protocol <= NPN_SPDY_MAXIMUM_VERSION) {if (origin.host() != alternative_service.host &&!session_->params().enable_http2_alternative_service_with_different_host) {continue;}// Cache this entry if we don't have a non-broken Alt-Svc yet.if (first_alternative_service.protocol ==UNINITIALIZED_ALTERNATE_PROTOCOL)first_alternative_service = alternative_service;continue;}DCHECK_EQ(QUIC, alternative_service.protocol);if (origin.host() != alternative_service.host &&!session_->params().enable_quic_alternative_service_with_different_host) {continue;}quic_all_broken = false;if (!session_->params().enable_quic)continue;if (!IsQuicWhitelistedForHost(origin.host()))continue;if (stream_type == HttpStreamRequest::BIDIRECTIONAL_STREAM &&session_->params().quic_disable_bidirectional_streams) {continue;}if (session_->quic_stream_factory()->IsQuicDisabled(alternative_service.port))continue;if (!original_url.SchemeIs("https"))continue;// Check whether there is an existing QUIC session to use for this origin.HostPortPair mapped_origin(origin.host(), origin.port());ignore_result(ApplyHostMappingRules(original_url, &mapped_origin));QuicServerId server_id(mapped_origin, request_info.privacy_mode);HostPortPair destination(alternative_service.host_port_pair());ignore_result(ApplyHostMappingRules(original_url, &destination));if (session_->quic_stream_factory()->CanUseExistingSession(server_id,destination)) {return alternative_service;}// Cache this entry if we don't have a non-broken Alt-Svc yet.if (first_alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)first_alternative_service = alternative_service;}// Ask delegate to mark QUIC as broken for the origin.if (quic_advertised && quic_all_broken && delegate != nullptr)delegate->OnQuicBroken();return first_alternative_service; }

這個函數的執行流程如下：

檢查Url的scheme是否為https，若不是，直接返回空的AlternativeService。即備選服務只用于https。

從session_獲取HttpServerProperties http_server_properties。

從http_server_properties獲取所有的備選服務信息。

遍歷上一步找到的備選服務，找到一個可用的。

在Chromium net中，以https為scheme的請求有多種，一是常規的HTTP/1.1 + TLS的請求，二是SPDY/HTTP2請求，三是QUIC協議的請求。備選服務主要用于后兩種協議的請求。這里會根據同源策略、端口、協議是否打開及主機是否在白名單等判斷一個備選服務是否可用。

我們可以看到，備選服務的所有信息，都來源于http_server_properties。http_server_properties來源于HttpNetworkSession。HttpNetworkSession的http_server_properties在URLRequestContextBuilder::Build()中創建：

void URLRequestContextBuilder::SetHttpNetworkSessionComponents(const URLRequestContext* context,HttpNetworkSession::Params* params) {params->host_resolver = context->host_resolver();params->cert_verifier = context->cert_verifier();params->transport_security_state = context->transport_security_state();params->cert_transparency_verifier = context->cert_transparency_verifier();params->ct_policy_enforcer = context->ct_policy_enforcer();params->proxy_service = context->proxy_service();params->ssl_config_service = context->ssl_config_service();params->http_auth_handler_factory = context->http_auth_handler_factory();params->http_server_properties = context->http_server_properties();params->net_log = context->net_log();params->channel_id_service = context->channel_id_service(); }std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() { ......if (http_server_properties_) {storage->set_http_server_properties(std::move(http_server_properties_));} else {storage->set_http_server_properties(std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));} ......storage->set_http_network_session(base::WrapUnique(new HttpNetworkSession(network_session_params)));

Cronet庫的初始化過程中，會執行CronetURLRequestContextAdapter::InitializeOnNetworkThread()，在這個方法中，通過URLRequestContextBuilder構建了URLRequestContext之后，會向其中添加備選服務的信息：

void CronetURLRequestContextAdapter::InitializeOnNetworkThread(std::unique_ptr<URLRequestContextConfig> config,const base::android::ScopedJavaGlobalRef<jobject>&jcronet_url_request_context) { ......if (config->enable_quic) {for (auto hint = config->quic_hints.begin();hint != config->quic_hints.end(); ++hint) {const URLRequestContextConfig::QuicHint& quic_hint = **hint;if (quic_hint.host.empty()) {LOG(ERROR) << "Empty QUIC hint host: " << quic_hint.host;continue;}url::CanonHostInfo host_info;std::string canon_host(net::CanonicalizeHost(quic_hint.host, &host_info));if (!host_info.IsIPAddress() &&!net::IsCanonicalizedHostCompliant(canon_host)) {LOG(ERROR) << "Invalid QUIC hint host: " << quic_hint.host;continue;}if (quic_hint.port <= std::numeric_limits<uint16_t>::min() ||quic_hint.port > std::numeric_limits<uint16_t>::max()) {LOG(ERROR) << "Invalid QUIC hint port: "<< quic_hint.port;continue;}if (quic_hint.alternate_port <= std::numeric_limits<uint16_t>::min() ||quic_hint.alternate_port > std::numeric_limits<uint16_t>::max()) {LOG(ERROR) << "Invalid QUIC hint alternate port: "<< quic_hint.alternate_port;continue;}url::SchemeHostPort quic_server("https", canon_host, quic_hint.port);net::AlternativeService alternative_service(net::AlternateProtocol::QUIC, "",static_cast<uint16_t>(quic_hint.alternate_port));context_->http_server_properties()->SetAlternativeService(quic_server, alternative_service, base::Time::Max());}}

這里更是限定了只允許給QUIC協議添加備選服務。而這里添加的備選服務的信息都來自于URLRequestContextConfig。

繼續來看給HttpServerProperties添加備選服務信息的過程 (chromium_android/src/net/http/http_server_properties_impl.cc)：

bool HttpServerPropertiesImpl::SetAlternativeService(const url::SchemeHostPort& origin,const AlternativeService& alternative_service,base::Time expiration) {return SetAlternativeServices(origin,AlternativeServiceInfoVector(/*size=*/1, AlternativeServiceInfo(alternative_service, expiration))); }bool HttpServerPropertiesImpl::SetAlternativeServices(const url::SchemeHostPort& origin,const AlternativeServiceInfoVector& alternative_service_info_vector) {AlternativeServiceMap::iterator it = alternative_service_map_.Peek(origin);if (alternative_service_info_vector.empty()) {RemoveCanonicalHost(origin);if (it == alternative_service_map_.end())return false;alternative_service_map_.Erase(it);return true;}bool changed = true;if (it != alternative_service_map_.end()) {DCHECK(!it->second.empty());if (it->second.size() == alternative_service_info_vector.size()) {const base::Time now = base::Time::Now();changed = false;auto new_it = alternative_service_info_vector.begin();for (const auto& old : it->second) {// Persist to disk immediately if new entry has different scheme, host,// or port.if (old.alternative_service != new_it->alternative_service) {changed = true;break;}// Also persist to disk if new expiration it more that twice as far or// less than half as far in the future.base::Time old_time = old.expiration;base::Time new_time = new_it->expiration;if (new_time - now > 2 * (old_time - now) ||2 * (new_time - now) < (old_time - now)) {changed = true;break;}++new_it;}}}const bool previously_no_alternative_services =(GetAlternateProtocolIterator(origin) == alternative_service_map_.end());alternative_service_map_.Put(origin, alternative_service_info_vector);if (previously_no_alternative_services &&!GetAlternativeServices(origin).empty()) {// TODO(rch): Consider the case where multiple requests are started// before the first completes. In this case, only one of the jobs// would reach this code, whereas all of them should should have.HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);}// If this host ends with a canonical suffix, then set it as the// canonical host.const char* kCanonicalScheme = "https";if (origin.scheme() == kCanonicalScheme) {const std::string* canonical_suffix = GetCanonicalSuffix(origin.host());if (canonical_suffix != nullptr) {url::SchemeHostPort canonical_server(kCanonicalScheme, *canonical_suffix,origin.port());canonical_host_to_origin_map_[canonical_server] = origin;}}return changed; }

HttpServerPropertiesImpl用一個Map來管理備選服務的信息，key為原始服務的scheme+host+port，用url::SchemeHostPort來表示，而value則為AlternativeServiceInfoVector，即備選服務信息的列表。

用戶添加備選服務信息

在CronetEngine.Builder中 (chromium_android/src/components/cronet/android/api/src/org/chromium/net/CronetEngine.java)，提供了接口，來添加QUIC服務器的一些信息：

public abstract class CronetEngine {/*** A builder for {@link CronetEngine}s, which allows runtime configuration of* {@code CronetEngine}. Configuration options are set on the builder and* then {@link #build} is called to create the {@code CronetEngine}.*/public static class Builder {....../*** A hint that a host supports QUIC.* @hide only used by internal implementation.*/public static class QuicHint {// The host.public final String mHost;// Port of the server that supports QUIC.public final int mPort;// Alternate protocol port.public final int mAlternatePort;QuicHint(String host, int port, int alternatePort) {mHost = host;mPort = port;mAlternatePort = alternatePort;}}....../*** Adds hint that {@code host} supports QUIC.* Note that {@link #enableHttpCache enableHttpCache}* ({@link #HTTP_CACHE_DISK}) is needed to take advantage of 0-RTT* connection establishment between sessions.** @param host hostname of the server that supports QUIC.* @param port host of the server that supports QUIC.* @param alternatePort alternate port to use for QUIC.* @return the builder to facilitate chaining.*/public Builder addQuicHint(String host, int port, int alternatePort) {if (host.contains("/")) {throw new IllegalArgumentException("Illegal QUIC Hint Host: " + host);}mQuicHints.add(new QuicHint(host, port, alternatePort));return this;}/*** @hide only used by internal implementation.*/public List<QuicHint> quicHints() {return mQuicHints;}

在CronetUrlRequestContext創建中，創建native UrlRequestContextConfig時會將所有的QUIC hint信息傳遞給native層。

@VisibleForTestingpublic static long createNativeUrlRequestContextConfig(final Context context, CronetEngine.Builder builder) {final long urlRequestContextConfig = nativeCreateRequestContextConfig(builder.getUserAgent(), builder.storagePath(), builder.quicEnabled(),builder.getDefaultQuicUserAgentId(context), builder.http2Enabled(),builder.sdchEnabled(), builder.dataReductionProxyKey(),builder.dataReductionProxyPrimaryProxy(), builder.dataReductionProxyFallbackProxy(),builder.dataReductionProxySecureProxyCheckUrl(), builder.cacheDisabled(),builder.httpCacheMode(), builder.httpCacheMaxSize(), builder.experimentalOptions(),builder.mockCertVerifier(), builder.networkQualityEstimatorEnabled(),builder.publicKeyPinningBypassForLocalTrustAnchorsEnabled(),builder.certVerifierData());for (Builder.QuicHint quicHint : builder.quicHints()) {nativeAddQuicHint(urlRequestContextConfig, quicHint.mHost, quicHint.mPort,quicHint.mAlternatePort);}for (Builder.Pkp pkp : builder.publicKeyPins()) {nativeAddPkp(urlRequestContextConfig, pkp.mHost, pkp.mHashes, pkp.mIncludeSubdomains,pkp.mExpirationDate.getTime());}return urlRequestContextConfig;}

nativeAddQuicHint()在chromium_android/src/components/cronet/android/cronet_url_request_context_adapter.cc中定義：

// Add a QUIC hint to a URLRequestContextConfig. static void AddQuicHint(JNIEnv* env,const JavaParamRef<jclass>& jcaller,jlong jurl_request_context_config,const JavaParamRef<jstring>& jhost,jint jport,jint jalternate_port) {URLRequestContextConfig* config =reinterpret_cast<URLRequestContextConfig*>(jurl_request_context_config);config->quic_hints.push_back(base::WrapUnique(new URLRequestContextConfig::QuicHint(base::android::ConvertJavaStringToUTF8(env, jhost), jport,jalternate_port))); }

備選服務對HttpStreamFactoryImpl::Job::Job的操作的影響

為備選服務和為常規服務會以略有不同的方式創建Job：

HttpStreamFactoryImpl::Job::Job(Delegate* delegate,JobType job_type,HttpNetworkSession* session,const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HostPortPair destination,GURL origin_url,NetLog* net_log): Job(delegate,job_type,session,request_info,priority,server_ssl_config,proxy_ssl_config,destination,origin_url,AlternativeService(),net_log) {}HttpStreamFactoryImpl::Job::Job(Delegate* delegate,JobType job_type,HttpNetworkSession* session,const HttpRequestInfo& request_info,RequestPriority priority,const SSLConfig& server_ssl_config,const SSLConfig& proxy_ssl_config,HostPortPair destination,GURL origin_url,AlternativeService alternative_service,NetLog* net_log): request_info_(request_info),priority_(priority),server_ssl_config_(server_ssl_config),proxy_ssl_config_(proxy_ssl_config),net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP_STREAM_JOB)),io_callback_(base::Bind(&Job::OnIOComplete, base::Unretained(this))),connection_(new ClientSocketHandle),session_(session),next_state_(STATE_NONE),pac_request_(NULL),destination_(destination),origin_url_(origin_url),alternative_service_(alternative_service),delegate_(delegate),job_type_(job_type),using_ssl_(false),using_spdy_(false),using_quic_(false),quic_request_(session_->quic_stream_factory()),using_existing_quic_session_(false),spdy_certificate_error_(OK),establishing_tunnel_(false),was_npn_negotiated_(false),protocol_negotiated_(kProtoUnknown),num_streams_(0),spdy_session_direct_(false),job_status_(STATUS_RUNNING),other_job_status_(STATUS_RUNNING),stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),ptr_factory_(this) {DCHECK(session);if (IsSpdyAlternative()) {DCHECK(origin_url_.SchemeIs("https"));}if (IsQuicAlternative()) {DCHECK(session_->params().enable_quic);using_quic_ = true;} }......bool HttpStreamFactoryImpl::Job::IsQuicAlternative() const {return alternative_service_.protocol == QUIC; }

為QUIC備選服務創建的Job，在創建時期，就會將using_quic_置為true。這個標記的設置將對后續創建Stream的過程產生決定性的影響。

總結一下，備選服務機制像是一種過渡方案，用于在協議開發早期，還沒有確定協議協商機制的情況下。在chromium net中，scheme為https的請求所用的協議有可能是HTTP/1.1+TLS、HTTP2和QUIC這三種的任一種，其中前兩種都是基于TCP的，而QUIC是基于UDP的。當前前面的兩種協議已經有了NPN和ALPN這樣的協議協商的機制，而傳給chromium net一個scheme為https的QUIC請求的URL，它也是不知道要用QUIC協議來做請求的。而備選服務機制，則允許chromium net的用戶指定，對某些主機的訪問采用特定的協議進行。此外，在HttpStreamFactoryImpl::JobController的CreateJobs()中，在為備選服務創建Job之外，還是會創建main_job，即是說，傳給chromium net一個以https為scheme的Url，它一定會嘗試用TCP的方式建立連接的，只是對于請求QUIC協議的服務，這個連接將會失敗，而真正取回數據的將是alternative_job。

總結

以上是生活随笔為你收集整理的Cronet android 设计与实现分析——备选服务机制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。