diff options
Diffstat (limited to 'net')
38 files changed, 657 insertions, 655 deletions
diff --git a/net/base/dnsrr_resolver.h b/net/base/dnsrr_resolver.h index 9cc5bb8..3280774 100644 --- a/net/base/dnsrr_resolver.h +++ b/net/base/dnsrr_resolver.h @@ -26,6 +26,14 @@ struct RRResponse { RRResponse(); ~RRResponse(); + // HasExpired returns true if |fetch_time| + |ttl| is less than + // |current_time|. + bool HasExpired(base::Time current_time) const; + + // For testing only + bool ParseFromResponse(const uint8* data, unsigned len, + uint16 rrtype_requested); + // name contains the canonical name of the resulting domain. If the queried // name was a CNAME then this can differ. std::string name; @@ -42,14 +50,6 @@ struct RRResponse { // negative is true if this is a negative cache entry, i.e. is a placeholder // to remember that a given RR doesn't exist. bool negative; - - // HasExpired returns true if |fetch_time| + |ttl| is less than - // |current_time|. - bool HasExpired(base::Time current_time) const; - - // For testing only - bool ParseFromResponse(const uint8* data, unsigned len, - uint16 rrtype_requested); }; class BoundNetLog; @@ -69,6 +69,8 @@ class RRResolverJob; class DnsRRResolver : public base::NonThreadSafe, public NetworkChangeNotifier::Observer { public: + typedef intptr_t Handle; + enum { kInvalidHandle = 0, }; @@ -79,8 +81,6 @@ class DnsRRResolver : public base::NonThreadSafe, FLAG_WANT_DNSSEC = 1, }; - typedef intptr_t Handle; - DnsRRResolver(); ~DnsRRResolver(); diff --git a/net/base/dnssec_keyset.cc b/net/base/dnssec_keyset.cc index 70aa217..c7f8606 100644 --- a/net/base/dnssec_keyset.cc +++ b/net/base/dnssec_keyset.cc @@ -15,6 +15,19 @@ #include "base/time.h" #include "net/base/dns_util.h" +namespace { + +// These are encoded AlgorithmIdentifiers for the given signature algorithm. +const unsigned char kRSAWithSHA1[] = { + 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0x5, 5, 0 +}; + +const unsigned char kRSAWithSHA256[] = { + 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0xb, 5, 0 +}; + +} // namespace + namespace net { DNSSECKeySet::DNSSECKeySet() @@ -35,33 +48,6 @@ bool DNSSECKeySet::AddKey(const base::StringPiece& dnskey) { return true; } -// static -uint16 DNSSECKeySet::DNSKEYToKeyID(const base::StringPiece& dnskey) { - const unsigned char* data = - reinterpret_cast<const unsigned char*>(dnskey.data()); - - // RFC 4043: App B - uint32 ac = 0; - for (unsigned i = 0; i < dnskey.size(); i++) { - if (i & 1) { - ac += data[i]; - } else { - ac += static_cast<uint32>(data[i]) << 8; - } - } - ac += (ac >> 16) & 0xffff; - return ac; -} - -// These are encoded AlgorithmIdentifiers for the given signature algorithm. -static const unsigned char kRSAWithSHA1[] = { - 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0x5, 5, 0 -}; - -static const unsigned char kRSAWithSHA256[] = { - 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0xb, 5, 0 -}; - bool DNSSECKeySet::CheckSignature( const base::StringPiece& name, const base::StringPiece& zone, @@ -180,10 +166,109 @@ bool DNSSECKeySet::CheckSignature( return false; } +// static +uint16 DNSSECKeySet::DNSKEYToKeyID(const base::StringPiece& dnskey) { + const unsigned char* data = + reinterpret_cast<const unsigned char*>(dnskey.data()); + + // RFC 4043: App B + uint32 ac = 0; + for (unsigned i = 0; i < dnskey.size(); i++) { + if (i & 1) { + ac += data[i]; + } else { + ac += static_cast<uint32>(data[i]) << 8; + } + } + ac += (ac >> 16) & 0xffff; + return ac; +} + void DNSSECKeySet::IgnoreTimestamps() { ignore_timestamps_ = true; } +bool DNSSECKeySet::VerifySignature( + base::StringPiece signature_algorithm, + base::StringPiece signature, + base::StringPiece public_key, + base::StringPiece signed_data) { + // This code is largely a copy-and-paste from + // base/crypto/signature_verifier_nss.cc. We can't change + // base::SignatureVerifier to always use NSS because we want the ability to + // be FIPS 140-2 compliant. However, we can't use base::SignatureVerifier + // here because some platforms don't support SHA256 signatures. Therefore, we + // use NSS directly. + + base::EnsureNSSInit(); + + CERTSubjectPublicKeyInfo* spki = NULL; + SECItem spki_der; + spki_der.type = siBuffer; + spki_der.data = (uint8*) public_key.data(); + spki_der.len = public_key.size(); + spki = SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_der); + if (!spki) + return false; + SECKEYPublicKey* pub_key = SECKEY_ExtractPublicKey(spki); + SECKEY_DestroySubjectPublicKeyInfo(spki); // Done with spki. + if (!pub_key) + return false; + + PLArenaPool* arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); + if (!arena) { + SECKEY_DestroyPublicKey(pub_key); + return false; + } + + SECItem sig_alg_der; + sig_alg_der.type = siBuffer; + sig_alg_der.data = (uint8*) signature_algorithm.data(); + sig_alg_der.len = signature_algorithm.size(); + SECAlgorithmID sig_alg_id; + SECStatus rv; + rv = SEC_QuickDERDecodeItem(arena, &sig_alg_id, SECOID_AlgorithmIDTemplate, + &sig_alg_der); + if (rv != SECSuccess) { + SECKEY_DestroyPublicKey(pub_key); + PORT_FreeArena(arena, PR_TRUE); + return false; + } + + SECItem sig; + sig.type = siBuffer; + sig.data = (uint8*) signature.data(); + sig.len = signature.size(); + SECOidTag hash_alg_tag; + VFYContext* vfy_context = + VFY_CreateContextWithAlgorithmID(pub_key, &sig, + &sig_alg_id, &hash_alg_tag, + NULL); + SECKEY_DestroyPublicKey(pub_key); + PORT_FreeArena(arena, PR_TRUE); // Done with sig_alg_id. + if (!vfy_context) { + // A corrupted RSA signature could be detected without the data, so + // VFY_CreateContextWithAlgorithmID may fail with SEC_ERROR_BAD_SIGNATURE + // (-8182). + return false; + } + + rv = VFY_Begin(vfy_context); + if (rv != SECSuccess) { + NOTREACHED(); + return false; + } + rv = VFY_Update(vfy_context, (uint8*) signed_data.data(), signed_data.size()); + if (rv != SECSuccess) { + NOTREACHED(); + return false; + } + rv = VFY_End(vfy_context); + VFY_DestroyContext(vfy_context, PR_TRUE); + + return rv == SECSuccess; +} + // This is an ASN.1 encoded AlgorithmIdentifier for RSA static const unsigned char kASN1AlgorithmIdentifierRSA[] = { 0x30, // SEQUENCE @@ -373,85 +458,4 @@ std::string DNSSECKeySet::ASN1WrapDNSKEY(const base::StringPiece& dnskey) { return std::string(reinterpret_cast<char*>(out.get()), j); } -bool DNSSECKeySet::VerifySignature( - base::StringPiece signature_algorithm, - base::StringPiece signature, - base::StringPiece public_key, - base::StringPiece signed_data) { - // This code is largely a copy-and-paste from - // base/crypto/signature_verifier_nss.cc. We can't change - // base::SignatureVerifier to always use NSS because we want the ability to - // be FIPS 140-2 compliant. However, we can't use base::SignatureVerifier - // here because some platforms don't support SHA256 signatures. Therefore, we - // use NSS directly. - - base::EnsureNSSInit(); - - CERTSubjectPublicKeyInfo* spki = NULL; - SECItem spki_der; - spki_der.type = siBuffer; - spki_der.data = (uint8*) public_key.data(); - spki_der.len = public_key.size(); - spki = SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_der); - if (!spki) - return false; - SECKEYPublicKey* pub_key = SECKEY_ExtractPublicKey(spki); - SECKEY_DestroySubjectPublicKeyInfo(spki); // Done with spki. - if (!pub_key) - return false; - - PLArenaPool* arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); - if (!arena) { - SECKEY_DestroyPublicKey(pub_key); - return false; - } - - SECItem sig_alg_der; - sig_alg_der.type = siBuffer; - sig_alg_der.data = (uint8*) signature_algorithm.data(); - sig_alg_der.len = signature_algorithm.size(); - SECAlgorithmID sig_alg_id; - SECStatus rv; - rv = SEC_QuickDERDecodeItem(arena, &sig_alg_id, SECOID_AlgorithmIDTemplate, - &sig_alg_der); - if (rv != SECSuccess) { - SECKEY_DestroyPublicKey(pub_key); - PORT_FreeArena(arena, PR_TRUE); - return false; - } - - SECItem sig; - sig.type = siBuffer; - sig.data = (uint8*) signature.data(); - sig.len = signature.size(); - SECOidTag hash_alg_tag; - VFYContext* vfy_context = - VFY_CreateContextWithAlgorithmID(pub_key, &sig, - &sig_alg_id, &hash_alg_tag, - NULL); - SECKEY_DestroyPublicKey(pub_key); - PORT_FreeArena(arena, PR_TRUE); // Done with sig_alg_id. - if (!vfy_context) { - // A corrupted RSA signature could be detected without the data, so - // VFY_CreateContextWithAlgorithmID may fail with SEC_ERROR_BAD_SIGNATURE - // (-8182). - return false; - } - - rv = VFY_Begin(vfy_context); - if (rv != SECSuccess) { - NOTREACHED(); - return false; - } - rv = VFY_Update(vfy_context, (uint8*) signed_data.data(), signed_data.size()); - if (rv != SECSuccess) { - NOTREACHED(); - return false; - } - rv = VFY_End(vfy_context); - VFY_DestroyContext(vfy_context, PR_TRUE); - - return rv == SECSuccess; -} - } // namespace net diff --git a/net/base/file_stream.h b/net/base/file_stream.h index 6a53204..52e9ce9 100644 --- a/net/base/file_stream.h +++ b/net/base/file_stream.h @@ -130,6 +130,7 @@ class FileStream { // // This method should not be called if the stream was opened READ_ONLY. int Flush(); + private: class AsyncContext; friend class AsyncContext; diff --git a/net/base/file_stream_posix.cc b/net/base/file_stream_posix.cc index 21abd20..ecf064e 100644 --- a/net/base/file_stream_posix.cc +++ b/net/base/file_stream_posix.cc @@ -454,13 +454,6 @@ int FileStream::Write( } } -int FileStream::Flush() { - if (!IsOpen()) - return ERR_UNEXPECTED; - - return FlushFile(file_); -} - int64 FileStream::Truncate(int64 bytes) { if (!IsOpen()) return ERR_UNEXPECTED; @@ -478,4 +471,11 @@ int64 FileStream::Truncate(int64 bytes) { return result == 0 ? seek_position : MapErrorCode(errno); } +int FileStream::Flush() { + if (!IsOpen()) + return ERR_UNEXPECTED; + + return FlushFile(file_); +} + } // namespace net diff --git a/net/base/filter.cc b/net/base/filter.cc index 5e47ecb..309eab3 100644 --- a/net/base/filter.cc +++ b/net/base/filter.cc @@ -39,6 +39,8 @@ const char kTextHtml[] = "text/html"; FilterContext::~FilterContext() { } +Filter::~Filter() {} + Filter* Filter::Factory(const std::vector<FilterType>& filter_types, const FilterContext& filter_context) { DCHECK_GT(filter_context.GetInputStreamBufferSize(), 0); @@ -56,6 +58,59 @@ Filter* Filter::Factory(const std::vector<FilterType>& filter_types, return filter_list; } +Filter::FilterStatus Filter::ReadData(char* dest_buffer, int* dest_len) { + const int dest_buffer_capacity = *dest_len; + if (last_status_ == FILTER_ERROR) + return last_status_; + if (!next_filter_.get()) + return last_status_ = ReadFilteredData(dest_buffer, dest_len); + if (last_status_ == FILTER_NEED_MORE_DATA && !stream_data_len()) + return next_filter_->ReadData(dest_buffer, dest_len); + + do { + if (next_filter_->last_status() == FILTER_NEED_MORE_DATA) { + PushDataIntoNextFilter(); + if (FILTER_ERROR == last_status_) + return FILTER_ERROR; + } + *dest_len = dest_buffer_capacity; // Reset the input/output parameter. + next_filter_->ReadData(dest_buffer, dest_len); + if (FILTER_NEED_MORE_DATA == last_status_) + return next_filter_->last_status(); + + // In the case where this filter has data internally, and is indicating such + // with a last_status_ of FILTER_OK, but at the same time the next filter in + // the chain indicated it FILTER_NEED_MORE_DATA, we have to be cautious + // about confusing the caller. The API confusion can appear if we return + // FILTER_OK (suggesting we have more data in aggregate), but yet we don't + // populate our output buffer. When that is the case, we need to + // alternately call our filter element, and the next_filter element until we + // get out of this state (by pumping data into the next filter until it + // outputs data, or it runs out of data and reports that it NEED_MORE_DATA.) + } while (FILTER_OK == last_status_ && + FILTER_NEED_MORE_DATA == next_filter_->last_status() && + 0 == *dest_len); + + if (next_filter_->last_status() == FILTER_ERROR) + return FILTER_ERROR; + return FILTER_OK; +} + +bool Filter::FlushStreamBuffer(int stream_data_len) { + DCHECK(stream_data_len <= stream_buffer_size_); + if (stream_data_len <= 0 || stream_data_len > stream_buffer_size_) + return false; + + DCHECK(stream_buffer()); + // Bail out if there is more data in the stream buffer to be filtered. + if (!stream_buffer() || stream_data_len_) + return false; + + next_stream_data_ = stream_buffer()->data(); + stream_data_len_ = stream_data_len; + return true; +} + // static Filter::FilterType Filter::ConvertEncodingToType( const std::string& filter_type) { @@ -232,6 +287,42 @@ void Filter::FixupEncodingTypes( return; } +Filter::Filter(const FilterContext& filter_context) + : stream_buffer_(NULL), + stream_buffer_size_(0), + next_stream_data_(NULL), + stream_data_len_(0), + next_filter_(NULL), + last_status_(FILTER_NEED_MORE_DATA), + filter_context_(filter_context) { +} + +Filter::FilterStatus Filter::ReadFilteredData(char* dest_buffer, + int* dest_len) { + return Filter::FILTER_ERROR; +} + +Filter::FilterStatus Filter::CopyOut(char* dest_buffer, int* dest_len) { + int out_len; + int input_len = *dest_len; + *dest_len = 0; + + if (0 == stream_data_len_) + return Filter::FILTER_NEED_MORE_DATA; + + out_len = std::min(input_len, stream_data_len_); + memcpy(dest_buffer, next_stream_data_, out_len); + *dest_len += out_len; + stream_data_len_ -= out_len; + if (0 == stream_data_len_) { + next_stream_data_ = NULL; + return Filter::FILTER_NEED_MORE_DATA; + } else { + next_stream_data_ += out_len; + return Filter::FILTER_OK; + } +} + // static Filter* Filter::PrependNewFilter(FilterType type_id, const FilterContext& filter_context, @@ -274,18 +365,6 @@ Filter* Filter::PrependNewFilter(FilterType type_id, return first_filter; } -Filter::Filter(const FilterContext& filter_context) - : stream_buffer_(NULL), - stream_buffer_size_(0), - next_stream_data_(NULL), - stream_data_len_(0), - next_filter_(NULL), - last_status_(FILTER_NEED_MORE_DATA), - filter_context_(filter_context) { -} - -Filter::~Filter() {} - bool Filter::InitBuffer() { int buffer_size = filter_context_.GetInputStreamBufferSize(); DCHECK_GT(buffer_size, 0); @@ -302,72 +381,6 @@ bool Filter::InitBuffer() { return false; } - -Filter::FilterStatus Filter::CopyOut(char* dest_buffer, int* dest_len) { - int out_len; - int input_len = *dest_len; - *dest_len = 0; - - if (0 == stream_data_len_) - return Filter::FILTER_NEED_MORE_DATA; - - out_len = std::min(input_len, stream_data_len_); - memcpy(dest_buffer, next_stream_data_, out_len); - *dest_len += out_len; - stream_data_len_ -= out_len; - if (0 == stream_data_len_) { - next_stream_data_ = NULL; - return Filter::FILTER_NEED_MORE_DATA; - } else { - next_stream_data_ += out_len; - return Filter::FILTER_OK; - } -} - - -Filter::FilterStatus Filter::ReadFilteredData(char* dest_buffer, - int* dest_len) { - return Filter::FILTER_ERROR; -} - -Filter::FilterStatus Filter::ReadData(char* dest_buffer, int* dest_len) { - const int dest_buffer_capacity = *dest_len; - if (last_status_ == FILTER_ERROR) - return last_status_; - if (!next_filter_.get()) - return last_status_ = ReadFilteredData(dest_buffer, dest_len); - if (last_status_ == FILTER_NEED_MORE_DATA && !stream_data_len()) - return next_filter_->ReadData(dest_buffer, dest_len); - - do { - if (next_filter_->last_status() == FILTER_NEED_MORE_DATA) { - PushDataIntoNextFilter(); - if (FILTER_ERROR == last_status_) - return FILTER_ERROR; - } - *dest_len = dest_buffer_capacity; // Reset the input/output parameter. - next_filter_->ReadData(dest_buffer, dest_len); - if (FILTER_NEED_MORE_DATA == last_status_) - return next_filter_->last_status(); - - // In the case where this filter has data internally, and is indicating such - // with a last_status_ of FILTER_OK, but at the same time the next filter in - // the chain indicated it FILTER_NEED_MORE_DATA, we have to be cautious - // about confusing the caller. The API confusion can appear if we return - // FILTER_OK (suggesting we have more data in aggregate), but yet we don't - // populate our output buffer. When that is the case, we need to - // alternately call our filter element, and the next_filter element until we - // get out of this state (by pumping data into the next filter until it - // outputs data, or it runs out of data and reports that it NEED_MORE_DATA.) - } while (FILTER_OK == last_status_ && - FILTER_NEED_MORE_DATA == next_filter_->last_status() && - 0 == *dest_len); - - if (next_filter_->last_status() == FILTER_ERROR) - return FILTER_ERROR; - return FILTER_OK; -} - void Filter::PushDataIntoNextFilter() { net::IOBuffer* next_buffer = next_filter_->stream_buffer(); int next_size = next_filter_->stream_buffer_size(); @@ -375,19 +388,3 @@ void Filter::PushDataIntoNextFilter() { if (FILTER_ERROR != last_status_) next_filter_->FlushStreamBuffer(next_size); } - - -bool Filter::FlushStreamBuffer(int stream_data_len) { - DCHECK(stream_data_len <= stream_buffer_size_); - if (stream_data_len <= 0 || stream_data_len > stream_buffer_size_) - return false; - - DCHECK(stream_buffer()); - // Bail out if there is more data in the stream buffer to be filtered. - if (!stream_buffer() || stream_data_len_) - return false; - - next_stream_data_ = stream_buffer()->data(); - stream_data_len_ = stream_data_len; - return true; -} diff --git a/net/base/filter.h b/net/base/filter.h index d00a351..c6004e9 100644 --- a/net/base/filter.h +++ b/net/base/filter.h @@ -199,9 +199,10 @@ class Filter { std::vector<FilterType>* encoding_types); protected: + FRIEND_TEST_ALL_PREFIXES(SdchFilterTest, ContentTypeId); + explicit Filter(const FilterContext& filter_context); - FRIEND_TEST_ALL_PREFIXES(SdchFilterTest, ContentTypeId); // Filters the data stored in stream_buffer_ and writes the output into the // dest_buffer passed in. // diff --git a/net/base/host_resolver.cc b/net/base/host_resolver.cc index a8b642a..49678a2 100644 --- a/net/base/host_resolver.cc +++ b/net/base/host_resolver.cc @@ -19,9 +19,6 @@ HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair) priority_(MEDIUM) { } -HostResolver::HostResolver() { -} - HostResolver::~HostResolver() { } @@ -33,6 +30,9 @@ HostResolverImpl* HostResolver::GetAsHostResolverImpl() { return NULL; } +HostResolver::HostResolver() { +} + SingleRequestHostResolver::SingleRequestHostResolver(HostResolver* resolver) : resolver_(resolver), cur_request_(NULL), diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc index 6e4637c..b4c8bfa 100644 --- a/net/base/host_resolver_impl.cc +++ b/net/base/host_resolver_impl.cc @@ -944,6 +944,24 @@ HostResolverImpl::~HostResolverImpl() { delete job_pools_[i]; } +void HostResolverImpl::ProbeIPv6Support() { + DCHECK(CalledOnValidThread()); + DCHECK(!ipv6_probe_monitoring_); + ipv6_probe_monitoring_ = true; + OnIPAddressChanged(); // Give initial setup call. +} + +void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index, + size_t max_outstanding_jobs, + size_t max_pending_requests) { + DCHECK(CalledOnValidThread()); + CHECK_GE(pool_index, 0); + CHECK_LT(pool_index, POOL_COUNT); + CHECK(jobs_.empty()) << "Can only set constraints during setup"; + JobPool* pool = job_pools_[pool_index]; + pool->SetConstraints(max_outstanding_jobs, max_pending_requests); +} + int HostResolverImpl::Resolve(const RequestInfo& info, AddressList* addresses, CompletionCallback* callback, @@ -1125,13 +1143,6 @@ AddressFamily HostResolverImpl::GetDefaultAddressFamily() const { return default_address_family_; } -void HostResolverImpl::ProbeIPv6Support() { - DCHECK(CalledOnValidThread()); - DCHECK(!ipv6_probe_monitoring_); - ipv6_probe_monitoring_ = true; - OnIPAddressChanged(); // Give initial setup call. -} - HostResolverImpl* HostResolverImpl::GetAsHostResolverImpl() { return this; } @@ -1146,17 +1157,6 @@ void HostResolverImpl::Shutdown() { shutdown_ = true; } -void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index, - size_t max_outstanding_jobs, - size_t max_pending_requests) { - DCHECK(CalledOnValidThread()); - CHECK_GE(pool_index, 0); - CHECK_LT(pool_index, POOL_COUNT); - CHECK(jobs_.empty()) << "Can only set constraints during setup"; - JobPool* pool = job_pools_[pool_index]; - pool->SetConstraints(max_outstanding_jobs, max_pending_requests); -} - void HostResolverImpl::AddOutstandingJob(Job* job) { scoped_refptr<Job>& found_job = jobs_[job->key()]; DCHECK(!found_job); @@ -1305,28 +1305,6 @@ void HostResolverImpl::OnCancelRequest(const BoundNetLog& source_net_log, source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL, NULL); } -void HostResolverImpl::OnIPAddressChanged() { - if (cache_.get()) - cache_->clear(); - if (ipv6_probe_monitoring_) { - DCHECK(!shutdown_); - if (shutdown_) - return; - DiscardIPv6ProbeJob(); - ipv6_probe_job_ = new IPv6ProbeJob(this); - ipv6_probe_job_->Start(); - } -#if defined(OS_LINUX) - if (HaveOnlyLoopbackAddresses()) { - additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY; - } else { - additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY; - } -#endif - AbortAllInProgressJobs(); - // |this| may be deleted inside AbortAllInProgressJobs(). -} - void HostResolverImpl::DiscardIPv6ProbeJob() { if (ipv6_probe_job_.get()) { ipv6_probe_job_->Cancel(); @@ -1348,12 +1326,6 @@ void HostResolverImpl::IPv6ProbeSetDefaultAddressFamily( DiscardIPv6ProbeJob(); } -// static -HostResolverImpl::JobPoolIndex HostResolverImpl::GetJobPoolIndexForRequest( - const Request* req) { - return POOL_NORMAL; -} - bool HostResolverImpl::CanCreateJobForPool(const JobPool& pool) const { DCHECK_LE(jobs_.size(), max_jobs_); @@ -1365,6 +1337,12 @@ bool HostResolverImpl::CanCreateJobForPool(const JobPool& pool) const { return pool.CanCreateJob(); } +// static +HostResolverImpl::JobPoolIndex HostResolverImpl::GetJobPoolIndexForRequest( + const Request* req) { + return POOL_NORMAL; +} + void HostResolverImpl::ProcessQueuedRequests() { // Find the highest priority request that can be scheduled. Request* top_req = NULL; @@ -1458,4 +1436,26 @@ void HostResolverImpl::AbortAllInProgressJobs() { } } +void HostResolverImpl::OnIPAddressChanged() { + if (cache_.get()) + cache_->clear(); + if (ipv6_probe_monitoring_) { + DCHECK(!shutdown_); + if (shutdown_) + return; + DiscardIPv6ProbeJob(); + ipv6_probe_job_ = new IPv6ProbeJob(this); + ipv6_probe_job_->Start(); + } +#if defined(OS_LINUX) + if (HaveOnlyLoopbackAddresses()) { + additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY; + } else { + additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY; + } +#endif + AbortAllInProgressJobs(); + // |this| may be deleted inside AbortAllInProgressJobs(). +} + } // namespace net diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h index d6d82d0..a571bb7 100644 --- a/net/base/host_resolver_impl.h +++ b/net/base/host_resolver_impl.h @@ -87,29 +87,10 @@ class HostResolverImpl : public HostResolver, // be called. virtual ~HostResolverImpl(); - // HostResolver methods: - virtual int Resolve(const RequestInfo& info, - AddressList* addresses, - CompletionCallback* callback, - RequestHandle* out_req, - const BoundNetLog& source_net_log); - virtual void CancelRequest(RequestHandle req); - virtual void AddObserver(HostResolver::Observer* observer); - virtual void RemoveObserver(HostResolver::Observer* observer); - - // Set address family, and disable IPv6 probe support. - virtual void SetDefaultAddressFamily(AddressFamily address_family); - virtual AddressFamily GetDefaultAddressFamily() const; - // Continuously observe whether IPv6 is supported, and set the allowable // address family to IPv4 iff IPv6 is not supported. void ProbeIPv6Support(); - virtual HostResolverImpl* GetAsHostResolverImpl(); - - // TODO(eroman): hack for http://crbug.com/15513 - virtual void Shutdown(); - // Returns the cache this resolver uses, or NULL if caching is disabled. HostCache* cache() { return cache_.get(); } @@ -128,6 +109,25 @@ class HostResolverImpl : public HostResolver, size_t max_outstanding_jobs, size_t max_pending_requests); + // HostResolver methods: + virtual int Resolve(const RequestInfo& info, + AddressList* addresses, + CompletionCallback* callback, + RequestHandle* out_req, + const BoundNetLog& source_net_log); + virtual void CancelRequest(RequestHandle req); + virtual void AddObserver(HostResolver::Observer* observer); + virtual void RemoveObserver(HostResolver::Observer* observer); + + // Set address family, and disable IPv6 probe support. + virtual void SetDefaultAddressFamily(AddressFamily address_family); + virtual AddressFamily GetDefaultAddressFamily() const; + + virtual HostResolverImpl* GetAsHostResolverImpl(); + + // TODO(eroman): hack for http://crbug.com/15513 + virtual void Shutdown(); + private: class Job; class JobPool; @@ -185,9 +185,6 @@ class HostResolverImpl : public HostResolver, int request_id, const RequestInfo& info); - // NetworkChangeNotifier::Observer methods: - virtual void OnIPAddressChanged(); - // Notify IPv6ProbeJob not to call back, and discard reference to the job. void DiscardIPv6ProbeJob(); @@ -226,6 +223,9 @@ class HostResolverImpl : public HostResolver, // Aborts all in progress jobs (but might start new ones). void AbortAllInProgressJobs(); + // NetworkChangeNotifier::Observer methods: + virtual void OnIPAddressChanged(); + // Cache of host resolution results. scoped_ptr<HostCache> cache_; diff --git a/net/base/host_resolver_proc.cc b/net/base/host_resolver_proc.cc index f33195c..b1230fa 100644 --- a/net/base/host_resolver_proc.cc +++ b/net/base/host_resolver_proc.cc @@ -64,6 +64,25 @@ HostResolverProc::HostResolverProc(HostResolverProc* previous) { SetPreviousProc(default_proc_); } +HostResolverProc::~HostResolverProc() { +} + +int HostResolverProc::ResolveUsingPrevious( + const std::string& host, + AddressFamily address_family, + HostResolverFlags host_resolver_flags, + AddressList* addrlist, + int* os_error) { + if (previous_proc_) { + return previous_proc_->Resolve(host, address_family, host_resolver_flags, + addrlist, os_error); + } + + // Final fallback is the system resolver. + return SystemHostResolverProc(host, address_family, host_resolver_flags, + addrlist, os_error); +} + void HostResolverProc::SetPreviousProc(HostResolverProc* proc) { HostResolverProc* current_previous = previous_proc_; previous_proc_ = NULL; @@ -98,25 +117,6 @@ HostResolverProc* HostResolverProc::GetDefault() { return default_proc_; } -HostResolverProc::~HostResolverProc() { -} - -int HostResolverProc::ResolveUsingPrevious( - const std::string& host, - AddressFamily address_family, - HostResolverFlags host_resolver_flags, - AddressList* addrlist, - int* os_error) { - if (previous_proc_) { - return previous_proc_->Resolve(host, address_family, host_resolver_flags, - addrlist, os_error); - } - - // Final fallback is the system resolver. - return SystemHostResolverProc(host, address_family, host_resolver_flags, - addrlist, os_error); -} - int SystemHostResolverProc(const std::string& host, AddressFamily address_family, HostResolverFlags host_resolver_flags, diff --git a/net/base/io_buffer.cc b/net/base/io_buffer.cc index dfd4d38..7e5a1fe 100644 --- a/net/base/io_buffer.cc +++ b/net/base/io_buffer.cc @@ -52,11 +52,6 @@ DrainableIOBuffer::DrainableIOBuffer(IOBuffer* base, int size) used_(0) { } -DrainableIOBuffer::~DrainableIOBuffer() { - // The buffer is owned by the |base_| instance. - data_ = NULL; -} - void DrainableIOBuffer::DidConsume(int bytes) { SetOffset(used_ + bytes); } @@ -76,16 +71,17 @@ void DrainableIOBuffer::SetOffset(int bytes) { data_ = base_->data() + used_; } +DrainableIOBuffer::~DrainableIOBuffer() { + // The buffer is owned by the |base_| instance. + data_ = NULL; +} + GrowableIOBuffer::GrowableIOBuffer() : IOBuffer(), capacity_(0), offset_(0) { } -GrowableIOBuffer::~GrowableIOBuffer() { - data_ = NULL; -} - void GrowableIOBuffer::SetCapacity(int capacity) { DCHECK(capacity >= 0); // realloc will crash if it fails. @@ -111,14 +107,17 @@ char* GrowableIOBuffer::StartOfBuffer() { return real_data_.get(); } -PickledIOBuffer::PickledIOBuffer() : IOBuffer() {} +GrowableIOBuffer::~GrowableIOBuffer() { + data_ = NULL; +} -PickledIOBuffer::~PickledIOBuffer() { data_ = NULL; } +PickledIOBuffer::PickledIOBuffer() : IOBuffer() {} void PickledIOBuffer::Done() { data_ = const_cast<char*>(static_cast<const char*>(pickle_.data())); } +PickledIOBuffer::~PickledIOBuffer() { data_ = NULL; } WrappedIOBuffer::WrappedIOBuffer(const char* data) : IOBuffer(const_cast<char*>(data)) { diff --git a/net/base/mapped_host_resolver.h b/net/base/mapped_host_resolver.h index 4a94fba..0f84f6a 100644 --- a/net/base/mapped_host_resolver.h +++ b/net/base/mapped_host_resolver.h @@ -25,17 +25,6 @@ class MappedHostResolver : public HostResolver { explicit MappedHostResolver(HostResolver* impl); virtual ~MappedHostResolver(); - // HostResolver methods: - virtual int Resolve(const RequestInfo& info, - AddressList* addresses, - CompletionCallback* callback, - RequestHandle* out_req, - const BoundNetLog& net_log); - virtual void CancelRequest(RequestHandle req); - virtual void AddObserver(Observer* observer); - virtual void RemoveObserver(Observer* observer); - virtual HostResolverImpl* GetAsHostResolverImpl(); - // Adds a rule to this mapper. The format of the rule can be one of: // // "MAP" <hostname_pattern> <replacement_host> [":" <replacement_port>] @@ -53,6 +42,17 @@ class MappedHostResolver : public HostResolver { rules_.SetRulesFromString(rules_string); } + // HostResolver methods: + virtual int Resolve(const RequestInfo& info, + AddressList* addresses, + CompletionCallback* callback, + RequestHandle* out_req, + const BoundNetLog& net_log); + virtual void CancelRequest(RequestHandle req); + virtual void AddObserver(Observer* observer); + virtual void RemoveObserver(Observer* observer); + virtual HostResolverImpl* GetAsHostResolverImpl(); + private: scoped_ptr<HostResolver> impl_; diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc index a1817a2..dfce49f 100644 --- a/net/base/mock_host_resolver.cc +++ b/net/base/mock_host_resolver.cc @@ -45,37 +45,8 @@ int CreateIPAddress(const std::string& host, } // namespace -MockHostResolverBase::MockHostResolverBase(bool use_caching) - : use_caching_(use_caching) { - Reset(NULL); -} - MockHostResolverBase::~MockHostResolverBase() {} -int MockHostResolverBase::Resolve(const RequestInfo& info, - AddressList* addresses, - CompletionCallback* callback, - RequestHandle* out_req, - const BoundNetLog& net_log) { - if (synchronous_mode_) { - callback = NULL; - out_req = NULL; - } - return impl_->Resolve(info, addresses, callback, out_req, net_log); -} - -void MockHostResolverBase::CancelRequest(RequestHandle req) { - impl_->CancelRequest(req); -} - -void MockHostResolverBase::AddObserver(Observer* observer) { - impl_->AddObserver(observer); -} - -void MockHostResolverBase::RemoveObserver(Observer* observer) { - impl_->RemoveObserver(observer); -} - void MockHostResolverBase::Reset(HostResolverProc* interceptor) { synchronous_mode_ = false; @@ -107,6 +78,35 @@ void MockHostResolverBase::Reset(HostResolverProc* interceptor) { impl_.reset(new HostResolverImpl(proc, cache, 50u, NULL)); } +int MockHostResolverBase::Resolve(const RequestInfo& info, + AddressList* addresses, + CompletionCallback* callback, + RequestHandle* out_req, + const BoundNetLog& net_log) { + if (synchronous_mode_) { + callback = NULL; + out_req = NULL; + } + return impl_->Resolve(info, addresses, callback, out_req, net_log); +} + +void MockHostResolverBase::CancelRequest(RequestHandle req) { + impl_->CancelRequest(req); +} + +void MockHostResolverBase::AddObserver(Observer* observer) { + impl_->AddObserver(observer); +} + +void MockHostResolverBase::RemoveObserver(Observer* observer) { + impl_->RemoveObserver(observer); +} + +MockHostResolverBase::MockHostResolverBase(bool use_caching) + : use_caching_(use_caching) { + Reset(NULL); +} + //----------------------------------------------------------------------------- struct RuleBasedHostResolverProc::Rule { @@ -144,9 +144,6 @@ RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous) : HostResolverProc(previous) { } -RuleBasedHostResolverProc::~RuleBasedHostResolverProc() { -} - void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern, const std::string& replacement) { AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED, @@ -258,6 +255,9 @@ int RuleBasedHostResolverProc::Resolve(const std::string& host, host_resolver_flags, addrlist, os_error); } +RuleBasedHostResolverProc::~RuleBasedHostResolverProc() { +} + //----------------------------------------------------------------------------- WaitingHostResolverProc::WaitingHostResolverProc(HostResolverProc* previous) diff --git a/net/base/net_log.cc b/net/base/net_log.cc index 0f1bac4..4484a8a0 100644 --- a/net/base/net_log.cc +++ b/net/base/net_log.cc @@ -127,20 +127,6 @@ void BoundNetLog::AddEntryWithTime( } } -NetLog::LogLevel BoundNetLog::GetLogLevel() const { - if (net_log_) - return net_log_->GetLogLevel(); - return NetLog::LOG_BASIC; -} - -bool BoundNetLog::IsLoggingBytes() const { - return GetLogLevel() == NetLog::LOG_ALL; -} - -bool BoundNetLog::IsLoggingAllEvents() const { - return GetLogLevel() <= NetLog::LOG_ALL_BUT_BYTES; -} - void BoundNetLog::AddEvent( NetLog::EventType event_type, const scoped_refptr<NetLog::EventParameters>& params) const { @@ -171,6 +157,20 @@ void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type, } } +NetLog::LogLevel BoundNetLog::GetLogLevel() const { + if (net_log_) + return net_log_->GetLogLevel(); + return NetLog::LOG_BASIC; +} + +bool BoundNetLog::IsLoggingBytes() const { + return GetLogLevel() == NetLog::LOG_ALL; +} + +bool BoundNetLog::IsLoggingAllEvents() const { + return GetLogLevel() <= NetLog::LOG_ALL_BUT_BYTES; +} + // static BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLog::SourceType source_type) { diff --git a/net/base/ssl_config_service.cc b/net/base/ssl_config_service.cc index d02df38..f47392d 100644 --- a/net/base/ssl_config_service.cc +++ b/net/base/ssl_config_service.cc @@ -43,9 +43,6 @@ SSLConfigService::SSLConfigService() : observer_list_(ObserverList<Observer>::NOTIFY_EXISTING_ONLY) { } -SSLConfigService::~SSLConfigService() { -} - // static SSLConfigService* SSLConfigService::CreateSystemSSLConfigService() { #if defined(OS_WIN) @@ -100,16 +97,6 @@ static bool g_snap_start_enabled = false; static bool g_dns_cert_provenance_checking = false; // static -void SSLConfigService::SetSSLConfigFlags(SSLConfig* ssl_config) { - ssl_config->dnssec_enabled = g_dnssec_enabled; - ssl_config->false_start_enabled = g_false_start_enabled; - ssl_config->mitm_proxies_allowed = g_mitm_proxies_allowed; - ssl_config->snap_start_enabled = g_snap_start_enabled; - ssl_config->dns_cert_provenance_checking_enabled = - g_dns_cert_provenance_checking; -} - -// static void SSLConfigService::EnableDNSSEC() { g_dnssec_enabled = true; } @@ -130,23 +117,23 @@ bool SSLConfigService::snap_start_enabled() { } // static -void SSLConfigService::DisableFalseStart() { - g_false_start_enabled = false; +void SSLConfigService::AllowMITMProxies() { + g_mitm_proxies_allowed = true; } // static -bool SSLConfigService::false_start_enabled() { - return g_false_start_enabled; +bool SSLConfigService::mitm_proxies_allowed() { + return g_mitm_proxies_allowed; } // static -void SSLConfigService::AllowMITMProxies() { - g_mitm_proxies_allowed = true; +void SSLConfigService::DisableFalseStart() { + g_false_start_enabled = false; } // static -bool SSLConfigService::mitm_proxies_allowed() { - return g_mitm_proxies_allowed; +bool SSLConfigService::false_start_enabled() { + return g_false_start_enabled; } // static @@ -167,6 +154,19 @@ void SSLConfigService::RemoveObserver(Observer* observer) { observer_list_.RemoveObserver(observer); } +SSLConfigService::~SSLConfigService() { +} + +// static +void SSLConfigService::SetSSLConfigFlags(SSLConfig* ssl_config) { + ssl_config->dnssec_enabled = g_dnssec_enabled; + ssl_config->false_start_enabled = g_false_start_enabled; + ssl_config->mitm_proxies_allowed = g_mitm_proxies_allowed; + ssl_config->snap_start_enabled = g_snap_start_enabled; + ssl_config->dns_cert_provenance_checking_enabled = + g_dns_cert_provenance_checking; +} + void SSLConfigService::ProcessConfigUpdate(const SSLConfig& orig_config, const SSLConfig& new_config) { if (orig_config.rev_checking_enabled != new_config.rev_checking_enabled || diff --git a/net/base/transport_security_state.cc b/net/base/transport_security_state.cc index 32b7566..e5acfb3 100644 --- a/net/base/transport_security_state.cc +++ b/net/base/transport_security_state.cc @@ -100,6 +100,23 @@ bool TransportSecurityState::IsEnabledForHost(DomainState* result, return false; } +void TransportSecurityState::DeleteSince(const base::Time& time) { + bool dirtied = false; + + std::map<std::string, DomainState>::iterator i = enabled_hosts_.begin(); + while (i != enabled_hosts_.end()) { + if (i->second.created >= time) { + dirtied = true; + enabled_hosts_.erase(i++); + } else { + i++; + } + } + + if (dirtied) + DirtyNotify(); +} + // MaxAgeToInt converts a string representation of a number of seconds into a // int. We use strtol in order to handle overflow correctly. The string may // contain an arbitary number which we should truncate correctly rather than @@ -350,23 +367,6 @@ bool TransportSecurityState::Deserialise(const std::string& input, return true; } -void TransportSecurityState::DeleteSince(const base::Time& time) { - bool dirtied = false; - - std::map<std::string, DomainState>::iterator i = enabled_hosts_.begin(); - while (i != enabled_hosts_.end()) { - if (i->second.created >= time) { - dirtied = true; - enabled_hosts_.erase(i++); - } else { - i++; - } - } - - if (dirtied) - DirtyNotify(); -} - TransportSecurityState::~TransportSecurityState() { } diff --git a/net/base/upload_data_stream.cc b/net/base/upload_data_stream.cc index 329058c..0ec4c97 100644 --- a/net/base/upload_data_stream.cc +++ b/net/base/upload_data_stream.cc @@ -12,6 +12,9 @@ namespace net { +UploadDataStream::~UploadDataStream() { +} + UploadDataStream* UploadDataStream::Create(UploadData* data, int* error_code) { scoped_ptr<UploadDataStream> stream(new UploadDataStream(data)); int rv = stream->FillBuf(); @@ -23,21 +26,6 @@ UploadDataStream* UploadDataStream::Create(UploadData* data, int* error_code) { return stream.release(); } -UploadDataStream::UploadDataStream(UploadData* data) - : data_(data), - buf_(new IOBuffer(kBufSize)), - buf_len_(0), - next_element_(data->elements()->begin()), - next_element_offset_(0), - next_element_remaining_(0), - total_size_(data->GetContentLength()), - current_position_(0), - eof_(false) { -} - -UploadDataStream::~UploadDataStream() { -} - void UploadDataStream::DidConsume(size_t num_bytes) { DCHECK_LE(num_bytes, buf_len_); DCHECK(!eof_); @@ -51,6 +39,18 @@ void UploadDataStream::DidConsume(size_t num_bytes) { current_position_ += num_bytes; } +UploadDataStream::UploadDataStream(UploadData* data) + : data_(data), + buf_(new IOBuffer(kBufSize)), + buf_len_(0), + next_element_(data->elements()->begin()), + next_element_offset_(0), + next_element_remaining_(0), + total_size_(data->GetContentLength()), + current_position_(0), + eof_(false) { +} + int UploadDataStream::FillBuf() { std::vector<UploadData::Element>::iterator end = data_->elements()->end(); diff --git a/net/base/upload_data_stream.h b/net/base/upload_data_stream.h index 0d179d2..8583fb4 100644 --- a/net/base/upload_data_stream.h +++ b/net/base/upload_data_stream.h @@ -16,13 +16,13 @@ class IOBuffer; class UploadDataStream { public: + ~UploadDataStream(); + // Returns a new instance of UploadDataStream if it can be created and // initialized successfully. If not, NULL will be returned and the error // code will be set if the output parameter error_code is not empty. static UploadDataStream* Create(UploadData* data, int* error_code); - ~UploadDataStream(); - // Returns the stream's buffer and buffer length. IOBuffer* buf() const { return buf_; } size_t buf_len() const { return buf_len_; } @@ -44,6 +44,8 @@ class UploadDataStream { bool eof() const { return eof_; } private: + enum { kBufSize = 16384 }; + // Protects from public access since now we have a static creator function // which will do both creation and initialization and might return an error. explicit UploadDataStream(UploadData* data); @@ -59,7 +61,6 @@ class UploadDataStream { // always at the front of the buffer. If we cannot send all of the buffer at // once, then we memmove the remaining portion and back-fill the buffer for // the next "write" call. buf_len_ indicates how much data is in the buffer. - enum { kBufSize = 16384 }; scoped_refptr<IOBuffer> buf_; size_t buf_len_; diff --git a/net/disk_cache/disk_cache_test_util.h b/net/disk_cache/disk_cache_test_util.h index a0dbf21c..f957447 100644 --- a/net/disk_cache/disk_cache_test_util.h +++ b/net/disk_cache/disk_cache_test_util.h @@ -61,8 +61,8 @@ class CallbackTest : public CallbackRunner< Tuple1<int> > { explicit CallbackTest(bool reuse); virtual ~CallbackTest(); - virtual void RunWithParams(const Tuple1<int>& params); int result() const { return result_; } + virtual void RunWithParams(const Tuple1<int>& params); private: int result_; diff --git a/net/http/http_auth.cc b/net/http/http_auth.cc index 552d245..d5d6e0c 100644 --- a/net/http/http_auth.cc +++ b/net/http/http_auth.cc @@ -87,6 +87,24 @@ HttpAuth::AuthorizationResult HttpAuth::HandleChallengeResponse( return HttpAuth::AUTHORIZATION_RESULT_REJECT; } +HttpUtil::NameValuePairsIterator HttpAuth::ChallengeTokenizer::param_pairs() + const { + return HttpUtil::NameValuePairsIterator(params_begin_, params_end_, ','); +} + +std::string HttpAuth::ChallengeTokenizer::base64_param() const { + // Strip off any padding. + // (See https://bugzilla.mozilla.org/show_bug.cgi?id=230351.) + // + // Our base64 decoder requires that the length be a multiple of 4. + int encoded_length = params_end_ - params_begin_; + while (encoded_length > 0 && encoded_length % 4 != 0 && + params_begin_[encoded_length - 1] == '=') { + --encoded_length; + } + return std::string(params_begin_, params_begin_ + encoded_length); +} + void HttpAuth::ChallengeTokenizer::Init(std::string::const_iterator begin, std::string::const_iterator end) { // The first space-separated token is the auth-scheme. @@ -107,24 +125,6 @@ void HttpAuth::ChallengeTokenizer::Init(std::string::const_iterator begin, HttpUtil::TrimLWS(¶ms_begin_, ¶ms_end_); } -HttpUtil::NameValuePairsIterator HttpAuth::ChallengeTokenizer::param_pairs() - const { - return HttpUtil::NameValuePairsIterator(params_begin_, params_end_, ','); -} - -std::string HttpAuth::ChallengeTokenizer::base64_param() const { - // Strip off any padding. - // (See https://bugzilla.mozilla.org/show_bug.cgi?id=230351.) - // - // Our base64 decoder requires that the length be a multiple of 4. - int encoded_length = params_end_ - params_begin_; - while (encoded_length > 0 && encoded_length % 4 != 0 && - params_begin_[encoded_length - 1] == '=') { - --encoded_length; - } - return std::string(params_begin_, params_begin_ + encoded_length); -} - // static std::string HttpAuth::GetChallengeHeaderName(Target target) { switch (target) { diff --git a/net/http/http_auth_cache.cc b/net/http/http_auth_cache.cc index 3ab86c70..3e5007f 100644 --- a/net/http/http_auth_cache.cc +++ b/net/http/http_auth_cache.cc @@ -143,6 +143,12 @@ HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin, HttpAuthCache::Entry::~Entry() { } +void HttpAuthCache::Entry::UpdateStaleChallenge( + const std::string& auth_challenge) { + auth_challenge_ = auth_challenge; + nonce_count_ = 1; +} + HttpAuthCache::Entry::Entry() : nonce_count_(0) { } @@ -175,12 +181,6 @@ bool HttpAuthCache::Entry::HasEnclosingPath(const std::string& dir) { return false; } -void HttpAuthCache::Entry::UpdateStaleChallenge( - const std::string& auth_challenge) { - auth_challenge_ = auth_challenge; - nonce_count_ = 1; -} - bool HttpAuthCache::Remove(const GURL& origin, const std::string& realm, HttpAuth::Scheme scheme, diff --git a/net/http/http_net_log_params.h b/net/http/http_net_log_params.h index 1631363..c32250e 100644 --- a/net/http/http_net_log_params.h +++ b/net/http/http_net_log_params.h @@ -24,8 +24,6 @@ class NetLogHttpRequestParameter : public NetLog::EventParameters { NetLogHttpRequestParameter(const std::string& line, const HttpRequestHeaders& headers); - virtual Value* ToValue() const; - const HttpRequestHeaders& GetHeaders() const { return headers_; } @@ -34,6 +32,9 @@ class NetLogHttpRequestParameter : public NetLog::EventParameters { return line_; } + // NetLog::EventParameters + virtual Value* ToValue() const; + private: virtual ~NetLogHttpRequestParameter(); @@ -48,12 +49,13 @@ class NetLogHttpResponseParameter : public NetLog::EventParameters { explicit NetLogHttpResponseParameter( const scoped_refptr<HttpResponseHeaders>& headers); - virtual Value* ToValue() const; - const HttpResponseHeaders& GetHeaders() const { return *headers_; } + // NetLog::EventParameters + virtual Value* ToValue() const; + private: virtual ~NetLogHttpResponseParameter(); diff --git a/net/http/http_proxy_client_socket.cc b/net/http/http_proxy_client_socket.cc index 2f44428..692a6e3 100644 --- a/net/http/http_proxy_client_socket.cc +++ b/net/http/http_proxy_client_socket.cc @@ -62,6 +62,24 @@ HttpProxyClientSocket::~HttpProxyClientSocket() { Disconnect(); } +int HttpProxyClientSocket::RestartWithAuth(CompletionCallback* callback) { + DCHECK_EQ(STATE_NONE, next_state_); + DCHECK(!user_callback_); + + int rv = PrepareForAuthRestart(); + if (rv != OK) + return rv; + + rv = DoLoop(OK); + if (rv == ERR_IO_PENDING) + user_callback_ = callback; + return rv; +} + +const HttpResponseInfo* HttpProxyClientSocket::GetConnectResponseInfo() const { + return response_.headers ? &response_ : NULL; +} + HttpStream* HttpProxyClientSocket::CreateConnectResponseStream() { return new HttpBasicStream(transport_.release(), http_stream_parser_.release(), false); @@ -92,67 +110,6 @@ int HttpProxyClientSocket::Connect(CompletionCallback* callback) { return rv; } -int HttpProxyClientSocket::RestartWithAuth(CompletionCallback* callback) { - DCHECK_EQ(STATE_NONE, next_state_); - DCHECK(!user_callback_); - - int rv = PrepareForAuthRestart(); - if (rv != OK) - return rv; - - rv = DoLoop(OK); - if (rv == ERR_IO_PENDING) - user_callback_ = callback; - return rv; -} - -int HttpProxyClientSocket::PrepareForAuthRestart() { - if (!response_.headers.get()) - return ERR_CONNECTION_RESET; - - bool keep_alive = false; - if (response_.headers->IsKeepAlive() && - http_stream_parser_->CanFindEndOfResponse()) { - if (!http_stream_parser_->IsResponseBodyComplete()) { - next_state_ = STATE_DRAIN_BODY; - drain_buf_ = new IOBuffer(kDrainBodyBufferSize); - return OK; - } - keep_alive = true; - } - - // We don't need to drain the response body, so we act as if we had drained - // the response body. - return DidDrainBodyForAuthRestart(keep_alive); -} - -int HttpProxyClientSocket::DidDrainBodyForAuthRestart(bool keep_alive) { - if (keep_alive && transport_->socket()->IsConnectedAndIdle()) { - next_state_ = STATE_GENERATE_AUTH_TOKEN; - transport_->set_is_reused(true); - } else { - // This assumes that the underlying transport socket is a TCP socket, - // since only TCP sockets are restartable. - next_state_ = STATE_TCP_RESTART; - transport_->socket()->Disconnect(); - } - - // Reset the other member variables. - drain_buf_ = NULL; - parser_buf_ = NULL; - http_stream_parser_.reset(); - request_line_.clear(); - request_headers_.Clear(); - response_ = HttpResponseInfo(); - return OK; -} - -void HttpProxyClientSocket::LogBlockedTunnelResponse(int response_code) const { - LOG(WARNING) << "Blocked proxy response with status " << response_code - << " to CONNECT request for " - << GetHostAndPort(request_.url) << "."; -} - void HttpProxyClientSocket::Disconnect() { if (transport_.get()) transport_->socket()->Disconnect(); @@ -248,6 +205,64 @@ int HttpProxyClientSocket::GetPeerAddress(AddressList* address) const { return transport_->socket()->GetPeerAddress(address); } +int HttpProxyClientSocket::PrepareForAuthRestart() { + if (!response_.headers.get()) + return ERR_CONNECTION_RESET; + + bool keep_alive = false; + if (response_.headers->IsKeepAlive() && + http_stream_parser_->CanFindEndOfResponse()) { + if (!http_stream_parser_->IsResponseBodyComplete()) { + next_state_ = STATE_DRAIN_BODY; + drain_buf_ = new IOBuffer(kDrainBodyBufferSize); + return OK; + } + keep_alive = true; + } + + // We don't need to drain the response body, so we act as if we had drained + // the response body. + return DidDrainBodyForAuthRestart(keep_alive); +} + +int HttpProxyClientSocket::DidDrainBodyForAuthRestart(bool keep_alive) { + if (keep_alive && transport_->socket()->IsConnectedAndIdle()) { + next_state_ = STATE_GENERATE_AUTH_TOKEN; + transport_->set_is_reused(true); + } else { + // This assumes that the underlying transport socket is a TCP socket, + // since only TCP sockets are restartable. + next_state_ = STATE_TCP_RESTART; + transport_->socket()->Disconnect(); + } + + // Reset the other member variables. + drain_buf_ = NULL; + parser_buf_ = NULL; + http_stream_parser_.reset(); + request_line_.clear(); + request_headers_.Clear(); + response_ = HttpResponseInfo(); + return OK; +} + +int HttpProxyClientSocket::HandleAuthChallenge() { + DCHECK(response_.headers); + + int rv = auth_->HandleAuthChallenge(response_.headers, false, true, net_log_); + response_.auth_challenge = auth_->auth_info(); + if (rv == OK) + return ERR_PROXY_AUTH_REQUESTED; + + return rv; +} + +void HttpProxyClientSocket::LogBlockedTunnelResponse(int response_code) const { + LOG(WARNING) << "Blocked proxy response with status " << response_code + << " to CONNECT request for " + << GetHostAndPort(request_.url) << "."; +} + void HttpProxyClientSocket::DoCallback(int result) { DCHECK_NE(ERR_IO_PENDING, result); DCHECK(user_callback_); @@ -465,15 +480,4 @@ int HttpProxyClientSocket::DoTCPRestartComplete(int result) { return result; } -int HttpProxyClientSocket::HandleAuthChallenge() { - DCHECK(response_.headers); - - int rv = auth_->HandleAuthChallenge(response_.headers, false, true, net_log_); - response_.auth_challenge = auth_->auth_info(); - if (rv == OK) - return ERR_PROXY_AUTH_REQUESTED; - - return rv; -} - } // namespace net diff --git a/net/http/http_proxy_client_socket.h b/net/http/http_proxy_client_socket.h index 325951d..2cf3c6a 100644 --- a/net/http/http_proxy_client_socket.h +++ b/net/http/http_proxy_client_socket.h @@ -56,12 +56,6 @@ class HttpProxyClientSocket : public ProxyClientSocket { // RestartWithAuth. int RestartWithAuth(CompletionCallback* callback); - const HttpResponseInfo* GetConnectResponseInfo() const { - return response_.headers ? &response_ : NULL; - } - - virtual HttpStream* CreateConnectResponseStream(); - const scoped_refptr<HttpAuthController>& auth_controller() { return auth_; } @@ -70,9 +64,11 @@ class HttpProxyClientSocket : public ProxyClientSocket { return using_spdy_; } - // ClientSocket methods: + // ProxyClientSocket methods: + virtual const HttpResponseInfo* GetConnectResponseInfo() const; + virtual HttpStream* CreateConnectResponseStream(); - // Authenticates to the Http Proxy and then passes data freely. + // ClientSocket methods: virtual int Connect(CompletionCallback* callback); virtual void Disconnect(); virtual bool IsConnected() const; @@ -86,10 +82,8 @@ class HttpProxyClientSocket : public ProxyClientSocket { // Socket methods: virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback); - virtual bool SetReceiveBufferSize(int32 size); virtual bool SetSendBufferSize(int32 size); - virtual int GetPeerAddress(AddressList* address) const; private: diff --git a/net/http/http_stream_factory.cc b/net/http/http_stream_factory.cc index b575f48..4673d58 100644 --- a/net/http/http_stream_factory.cc +++ b/net/http/http_stream_factory.cc @@ -32,14 +32,6 @@ std::list<HostPortPair>* HttpStreamFactory::forced_spdy_exclusions_ = NULL; // static bool HttpStreamFactory::ignore_certificate_errors_ = false; -// static -void HttpStreamFactory::SetHostMappingRules(const std::string& rules) { - HostMappingRules* host_mapping_rules = new HostMappingRules(); - host_mapping_rules->SetRulesFromString(rules); - delete host_mapping_rules_; - host_mapping_rules_ = host_mapping_rules; -} - HttpStreamFactory::HttpStreamFactory() { } @@ -53,6 +45,14 @@ HttpStreamFactory::~HttpStreamFactory() { } } +// static +void HttpStreamFactory::SetHostMappingRules(const std::string& rules) { + HostMappingRules* host_mapping_rules = new HostMappingRules(); + host_mapping_rules->SetRulesFromString(rules); + delete host_mapping_rules_; + host_mapping_rules_ = host_mapping_rules; +} + StreamRequest* HttpStreamFactory::RequestStream( const HttpRequestInfo* request_info, SSLConfig* ssl_config, diff --git a/net/http/http_stream_factory.h b/net/http/http_stream_factory.h index 3bb6d2f..97bd79c 100644 --- a/net/http/http_stream_factory.h +++ b/net/http/http_stream_factory.h @@ -34,35 +34,6 @@ class HttpStreamFactory : public StreamFactory, HttpStreamFactory(); virtual ~HttpStreamFactory(); - // StreamFactory Interface - virtual StreamRequest* RequestStream(const HttpRequestInfo* info, - SSLConfig* ssl_config, - ProxyInfo* proxy_info, - HttpNetworkSession* session, - StreamRequest::Delegate* delegate, - const BoundNetLog& net_log); - - virtual int PreconnectStreams(int num_streams, - const HttpRequestInfo* info, - SSLConfig* ssl_config, - ProxyInfo* proxy_info, - HttpNetworkSession* session, - const BoundNetLog& net_log, - CompletionCallback* callback); - - virtual void AddTLSIntolerantServer(const GURL& url); - virtual bool IsTLSIntolerantServer(const GURL& url); - - virtual void ProcessAlternateProtocol( - HttpAlternateProtocols* alternate_protocols, - const std::string& alternate_protocol_str, - const HostPortPair& http_host_port_pair); - - virtual GURL ApplyHostMappingRules(const GURL& url, HostPortPair* endpoint); - - // HttpStreamRequest::PreconnectDelegate API - virtual void OnPreconnectsComplete(HttpStreamRequest* request, int result); - // Static settings // Turns spdy on or off. @@ -122,6 +93,31 @@ class HttpStreamFactory : public StreamFactory, static void SetHostMappingRules(const std::string& rules); + // StreamFactory Interface + virtual StreamRequest* RequestStream(const HttpRequestInfo* info, + SSLConfig* ssl_config, + ProxyInfo* proxy_info, + HttpNetworkSession* session, + StreamRequest::Delegate* delegate, + const BoundNetLog& net_log); + virtual int PreconnectStreams(int num_streams, + const HttpRequestInfo* info, + SSLConfig* ssl_config, + ProxyInfo* proxy_info, + HttpNetworkSession* session, + const BoundNetLog& net_log, + CompletionCallback* callback); + virtual void AddTLSIntolerantServer(const GURL& url); + virtual bool IsTLSIntolerantServer(const GURL& url); + virtual void ProcessAlternateProtocol( + HttpAlternateProtocols* alternate_protocols, + const std::string& alternate_protocol_str, + const HostPortPair& http_host_port_pair); + virtual GURL ApplyHostMappingRules(const GURL& url, HostPortPair* endpoint); + + // HttpStreamRequest::PreconnectDelegate API + virtual void OnPreconnectsComplete(HttpStreamRequest* request, int result); + private: typedef std::map<HttpStreamRequest*, CompletionCallback*> RequestCallbackMap; RequestCallbackMap request_callback_map_; diff --git a/net/proxy/init_proxy_resolver.h b/net/proxy/init_proxy_resolver.h index 2691be5..ec6bfc1 100644 --- a/net/proxy/init_proxy_resolver.h +++ b/net/proxy/init_proxy_resolver.h @@ -63,6 +63,15 @@ class InitProxyResolver { CompletionCallback* callback); private: + struct PacURL { + PacURL(bool auto_detect, const GURL& url) + : auto_detect(auto_detect), url(url) {} + bool auto_detect; + GURL url; + }; + + typedef std::vector<PacURL> UrlList; + enum State { STATE_NONE, STATE_WAIT, @@ -73,15 +82,6 @@ class InitProxyResolver { STATE_SET_PAC_SCRIPT_COMPLETE, }; - struct PacURL { - PacURL(bool auto_detect, const GURL& url) - : auto_detect(auto_detect), url(url) {} - bool auto_detect; - GURL url; - }; - - typedef std::vector<PacURL> UrlList; - // Returns ordered list of PAC urls to try for |config|. UrlList BuildPacUrlsFallbackList(const ProxyConfig& config) const; diff --git a/net/proxy/polling_proxy_config_service.cc b/net/proxy/polling_proxy_config_service.cc index 98a164d..01acac2 100644 --- a/net/proxy/polling_proxy_config_service.cc +++ b/net/proxy/polling_proxy_config_service.cc @@ -154,16 +154,6 @@ class PollingProxyConfigService::Core bool poll_task_queued_; }; -PollingProxyConfigService::PollingProxyConfigService( - base::TimeDelta poll_interval, - GetConfigFunction get_config_func) - : core_(new Core(poll_interval, get_config_func)) { -} - -PollingProxyConfigService::~PollingProxyConfigService() { - core_->Orphan(); -} - void PollingProxyConfigService::AddObserver(Observer* observer) { core_->AddObserver(observer); } @@ -180,6 +170,16 @@ void PollingProxyConfigService::OnLazyPoll() { core_->OnLazyPoll(); } +PollingProxyConfigService::PollingProxyConfigService( + base::TimeDelta poll_interval, + GetConfigFunction get_config_func) + : core_(new Core(poll_interval, get_config_func)) { +} + +PollingProxyConfigService::~PollingProxyConfigService() { + core_->Orphan(); +} + void PollingProxyConfigService::CheckForChangesNow() { core_->CheckForChangesNow(); } diff --git a/net/proxy/proxy_config.cc b/net/proxy/proxy_config.cc index ce14358..70e6549 100644 --- a/net/proxy/proxy_config.cc +++ b/net/proxy/proxy_config.cc @@ -32,17 +32,6 @@ ProxyConfig::ProxyRules::ProxyRules() ProxyConfig::ProxyRules::~ProxyRules() { } -bool ProxyConfig::ProxyRules::Equals(const ProxyRules& other) const { - return type == other.type && - single_proxy == other.single_proxy && - proxy_for_http == other.proxy_for_http && - proxy_for_https == other.proxy_for_https && - proxy_for_ftp == other.proxy_for_ftp && - fallback_proxy == other.fallback_proxy && - bypass_rules.Equals(other.bypass_rules) && - reverse_bypass == other.reverse_bypass; -} - void ProxyConfig::ProxyRules::Apply(const GURL& url, ProxyInfo* result) { if (empty()) { result->UseDirect(); @@ -146,6 +135,17 @@ const ProxyServer* ProxyConfig::ProxyRules::MapUrlSchemeToProxy( return NULL; // No mapping for this scheme. Use direct. } +bool ProxyConfig::ProxyRules::Equals(const ProxyRules& other) const { + return type == other.type && + single_proxy == other.single_proxy && + proxy_for_http == other.proxy_for_http && + proxy_for_https == other.proxy_for_https && + proxy_for_ftp == other.proxy_for_ftp && + fallback_proxy == other.fallback_proxy && + bypass_rules.Equals(other.bypass_rules) && + reverse_bypass == other.reverse_bypass; +} + ProxyServer* ProxyConfig::ProxyRules::MapUrlSchemeToProxyNoFallback( const std::string& scheme) { DCHECK_EQ(TYPE_PROXY_PER_SCHEME, type); diff --git a/net/socket/client_socket_handle.h b/net/socket/client_socket_handle.h index 406b9bb..8c5da88 100644 --- a/net/socket/client_socket_handle.h +++ b/net/socket/client_socket_handle.h @@ -31,12 +31,12 @@ namespace net { // class ClientSocketHandle { public: - typedef enum { + enum SocketReuseType { UNUSED = 0, // unused socket that just finished connecting UNUSED_IDLE, // unused socket that has been idle for awhile REUSED_IDLE, // previously used socket NUM_TYPES, - } SocketReuseType; + }; ClientSocketHandle(); ~ClientSocketHandle(); diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h index a1fd9ea..1798997c 100644 --- a/net/socket/client_socket_pool_base.h +++ b/net/socket/client_socket_pool_base.h @@ -298,8 +298,6 @@ class ClientSocketPoolBaseHelper // Entry for a persistent socket which became idle at time |start_time|. struct IdleSocket { IdleSocket() : socket(NULL) {} - ClientSocket* socket; - base::TimeTicks start_time; // An idle socket should be removed if it can't be reused, or has been idle // for too long. |now| is the current time value (TimeTicks::Now()). @@ -310,6 +308,9 @@ class ClientSocketPoolBaseHelper // mistaken for the beginning of the next response if we were to reuse the // socket for a new request. bool ShouldCleanup(base::TimeTicks now, base::TimeDelta timeout) const; + + ClientSocket* socket; + base::TimeTicks start_time; }; typedef std::deque<const Request* > RequestQueue; diff --git a/net/socket/ssl_client_socket_pool.h b/net/socket/ssl_client_socket_pool.h index 468d3ed1..d9d9594 100644 --- a/net/socket/ssl_client_socket_pool.h +++ b/net/socket/ssl_client_socket_pool.h @@ -229,14 +229,14 @@ class SSLClientSocketPool : public ClientSocketPool, virtual ClientSocketPoolHistograms* histograms() const; private: + typedef ClientSocketPoolBase<SSLSocketParams> PoolBase; + // SSLConfigService::Observer methods: // When the user changes the SSL config, we flush all idle sockets so they // won't get re-used. virtual void OnSSLConfigChanged(); - typedef ClientSocketPoolBase<SSLSocketParams> PoolBase; - class SSLConnectJobFactory : public PoolBase::ConnectJobFactory { public: SSLConnectJobFactory( diff --git a/net/socket/tcp_client_socket_pool.cc b/net/socket/tcp_client_socket_pool.cc index 5f017ea..4d71e2d 100644 --- a/net/socket/tcp_client_socket_pool.cc +++ b/net/socket/tcp_client_socket_pool.cc @@ -97,12 +97,6 @@ LoadState TCPConnectJob::GetLoadState() const { } } -int TCPConnectJob::ConnectInternal() { - next_state_ = STATE_RESOLVE_HOST; - start_time_ = base::TimeTicks::Now(); - return DoLoop(OK); -} - void TCPConnectJob::OnIOComplete(int result) { int rv = DoLoop(result); if (rv != ERR_IO_PENDING) @@ -188,6 +182,12 @@ int TCPConnectJob::DoTCPConnectComplete(int result) { return result; } +int TCPConnectJob::ConnectInternal() { + next_state_ = STATE_RESOLVE_HOST; + start_time_ = base::TimeTicks::Now(); + return DoLoop(OK); +} + ConnectJob* TCPClientSocketPool::TCPConnectJobFactory::NewConnectJob( const std::string& group_name, const PoolBase::Request& request, diff --git a/net/socket/tcp_client_socket_pool.h b/net/socket/tcp_client_socket_pool.h index e3986e5..4c19509 100644 --- a/net/socket/tcp_client_socket_pool.h +++ b/net/socket/tcp_client_socket_pool.h @@ -71,11 +71,6 @@ class TCPConnectJob : public ConnectJob { STATE_NONE, }; - // Begins the host resolution and the TCP connect. Returns OK on success - // and ERR_IO_PENDING if it cannot immediately service the request. - // Otherwise, it returns a net error code. - virtual int ConnectInternal(); - void OnIOComplete(int result); // Runs the state transition loop. @@ -86,6 +81,11 @@ class TCPConnectJob : public ConnectJob { int DoTCPConnect(); int DoTCPConnectComplete(int result); + // Begins the host resolution and the TCP connect. Returns OK on success + // and ERR_IO_PENDING if it cannot immediately service the request. + // Otherwise, it returns a net error code. + virtual int ConnectInternal(); + scoped_refptr<TCPSocketParams> params_; ClientSocketFactory* const client_socket_factory_; CompletionCallbackImpl<TCPConnectJob> callback_; diff --git a/net/spdy/spdy_frame_builder.cc b/net/spdy/spdy_frame_builder.cc index eed6eb2..c9d82e2 100644 --- a/net/spdy/spdy_frame_builder.cc +++ b/net/spdy/spdy_frame_builder.cc @@ -103,19 +103,14 @@ bool SpdyFrameBuilder::ReadData(void** iter, const char** data, return ReadBytes(iter, data, *length); } -char* SpdyFrameBuilder::BeginWrite(size_t length) { - size_t needed_size = length_ + length; - if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size))) - return NULL; - -#ifdef ARCH_CPU_64_BITS - DCHECK_LE(length, std::numeric_limits<uint32>::max()); -#endif +bool SpdyFrameBuilder::WriteString(const std::string& value) { + if (value.size() > 0xffff) + return false; - return buffer_ + length_; -} + if (!WriteUInt16(static_cast<int>(value.size()))) + return false; -void SpdyFrameBuilder::EndWrite(char* dest, int length) { + return WriteBytes(value.data(), static_cast<uint16>(value.size())); } bool SpdyFrameBuilder::WriteBytes(const void* data, uint16 data_len) { @@ -132,16 +127,6 @@ bool SpdyFrameBuilder::WriteBytes(const void* data, uint16 data_len) { return true; } -bool SpdyFrameBuilder::WriteString(const std::string& value) { - if (value.size() > 0xffff) - return false; - - if (!WriteUInt16(static_cast<int>(value.size()))) - return false; - - return WriteBytes(value.data(), static_cast<uint16>(value.size())); -} - char* SpdyFrameBuilder::BeginWriteData(uint16 length) { DCHECK_EQ(variable_buffer_offset_, 0U) << "There can only be one variable buffer in a SpdyFrameBuilder"; @@ -161,6 +146,21 @@ char* SpdyFrameBuilder::BeginWriteData(uint16 length) { return data_ptr; } +char* SpdyFrameBuilder::BeginWrite(size_t length) { + size_t needed_size = length_ + length; + if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size))) + return NULL; + +#ifdef ARCH_CPU_64_BITS + DCHECK_LE(length, std::numeric_limits<uint32>::max()); +#endif + + return buffer_ + length_; +} + +void SpdyFrameBuilder::EndWrite(char* dest, int length) { +} + bool SpdyFrameBuilder::Resize(size_t new_capacity) { if (new_capacity <= capacity_) return true; diff --git a/net/spdy/spdy_frame_builder.h b/net/spdy/spdy_frame_builder.h index 548cfda..36a3f53 100644 --- a/net/spdy/spdy_frame_builder.h +++ b/net/spdy/spdy_frame_builder.h @@ -33,7 +33,6 @@ namespace spdy { class SpdyFrameBuilder { public: SpdyFrameBuilder(); - ~SpdyFrameBuilder(); // Initializes a SpdyFrameBuilder from a const block of data. The data is // not copied; instead the data is merely referenced by this @@ -41,6 +40,8 @@ class SpdyFrameBuilder { // this way. SpdyFrameBuilder(const char* data, int data_len); + ~SpdyFrameBuilder(); + // Returns the size of the SpdyFrameBuilder's data. int length() const { return length_; } diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc index 5beeeb3..845ac38 100644 --- a/net/spdy/spdy_proxy_client_socket.cc +++ b/net/spdy/spdy_proxy_client_socket.cc @@ -59,6 +59,10 @@ SpdyProxyClientSocket::~SpdyProxyClientSocket() { Disconnect(); } +const HttpResponseInfo* SpdyProxyClientSocket::GetConnectResponseInfo() const { + return response_.headers ? &response_ : NULL; +} + HttpStream* SpdyProxyClientSocket::CreateConnectResponseStream() { DCHECK(response_stream_.get()); return response_stream_.release(); diff --git a/net/spdy/spdy_proxy_client_socket.h b/net/spdy/spdy_proxy_client_socket.h index e98dd9d..f66283e1 100644 --- a/net/spdy/spdy_proxy_client_socket.h +++ b/net/spdy/spdy_proxy_client_socket.h @@ -60,10 +60,7 @@ class SpdyProxyClientSocket : public ProxyClientSocket, } // ProxyClientSocket methods: - - virtual const HttpResponseInfo* GetConnectResponseInfo() const { - return response_.headers ? &response_ : NULL; - } + virtual const HttpResponseInfo* GetConnectResponseInfo() const; // In the event of a non-200 response to the CONNECT request, this // method may be called to return an HttpStream in order to read |