diff options
Diffstat (limited to 'net')
48 files changed, 279 insertions, 278 deletions
diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc index f938931..c7c2516 100644 --- a/net/base/capturing_net_log.cc +++ b/net/base/capturing_net_log.cc @@ -15,7 +15,7 @@ CapturingNetLog::CapturedEntry::CapturedEntry( const base::TimeTicks& time, Source source, EventPhase phase, - scoped_ptr<DictionaryValue> params) + scoped_ptr<base::DictionaryValue> params) : type(type), time(time), source(source), @@ -105,7 +105,7 @@ void CapturingNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) { // Using Dictionaries instead of Values makes checking values a little // simpler. - DictionaryValue* param_dict = NULL; + base::DictionaryValue* param_dict = NULL; Value* param_value = entry.ParametersToValue(); if (param_value && !param_value->GetAsDictionary(¶m_dict)) delete param_value; @@ -117,7 +117,7 @@ void CapturingNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) { base::TimeTicks::Now(), entry.source(), entry.phase(), - scoped_ptr<DictionaryValue>(param_dict))); + scoped_ptr<base::DictionaryValue>(param_dict))); } CapturingNetLog::CapturingNetLog() { diff --git a/net/base/file_stream_net_log_parameters.cc b/net/base/file_stream_net_log_parameters.cc index c268ecc..e85b625 100644 --- a/net/base/file_stream_net_log_parameters.cc +++ b/net/base/file_stream_net_log_parameters.cc @@ -13,7 +13,7 @@ base::Value* NetLogFileStreamErrorCallback( int os_error, net::Error net_error, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("operation", GetFileErrorSourceName(source)); dict->SetInteger("os_error", os_error); diff --git a/net/base/net_log.cc b/net/base/net_log.cc index ec4d472..b1ec72f 100644 --- a/net/base/net_log.cc +++ b/net/base/net_log.cc @@ -20,53 +20,53 @@ namespace { // bytes transferred and, if the log level indicates bytes should be logged and // |byte_count| > 0, the bytes themselves. The bytes are hex-encoded, since // base::StringValue only supports UTF-8. -Value* BytesTransferredCallback(int byte_count, - const char* bytes, - NetLog::LogLevel log_level) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* BytesTransferredCallback(int byte_count, + const char* bytes, + NetLog::LogLevel log_level) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("byte_count", byte_count); if (NetLog::IsLoggingBytes(log_level) && byte_count > 0) dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count)); return dict; } -Value* SourceEventParametersCallback(const NetLog::Source source, - NetLog::LogLevel /* log_level */) { +base::Value* SourceEventParametersCallback(const NetLog::Source source, + NetLog::LogLevel /* log_level */) { if (!source.IsValid()) return NULL; - DictionaryValue* event_params = new DictionaryValue(); + base::DictionaryValue* event_params = new base::DictionaryValue(); source.AddToEventParameters(event_params); return event_params; } -Value* NetLogIntegerCallback(const char* name, - int value, - NetLog::LogLevel /* log_level */) { - DictionaryValue* event_params = new DictionaryValue(); +base::Value* NetLogIntegerCallback(const char* name, + int value, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* event_params = new base::DictionaryValue(); event_params->SetInteger(name, value); return event_params; } -Value* NetLogInt64Callback(const char* name, - int64 value, - NetLog::LogLevel /* log_level */) { - DictionaryValue* event_params = new DictionaryValue(); +base::Value* NetLogInt64Callback(const char* name, + int64 value, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* event_params = new base::DictionaryValue(); event_params->SetString(name, base::Int64ToString(value)); return event_params; } -Value* NetLogStringCallback(const char* name, - const std::string* value, - NetLog::LogLevel /* log_level */) { - DictionaryValue* event_params = new DictionaryValue(); +base::Value* NetLogStringCallback(const char* name, + const std::string* value, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* event_params = new base::DictionaryValue(); event_params->SetString(name, *value); return event_params; } -Value* NetLogString16Callback(const char* name, - const base::string16* value, - NetLog::LogLevel /* log_level */) { - DictionaryValue* event_params = new DictionaryValue(); +base::Value* NetLogString16Callback(const char* name, + const base::string16* value, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* event_params = new base::DictionaryValue(); event_params->SetString(name, *value); return event_params; } @@ -86,8 +86,9 @@ bool NetLog::Source::IsValid() const { return id != kInvalidId; } -void NetLog::Source::AddToEventParameters(DictionaryValue* event_params) const { - DictionaryValue* dict = new DictionaryValue(); +void NetLog::Source::AddToEventParameters( + base::DictionaryValue* event_params) const { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("type", static_cast<int>(type)); dict->SetInteger("id", static_cast<int>(id)); event_params->Set("source_dependency", dict); @@ -99,8 +100,8 @@ NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const { // static bool NetLog::Source::FromEventParameters(Value* event_params, Source* source) { - DictionaryValue* dict; - DictionaryValue* source_dict; + base::DictionaryValue* dict; + base::DictionaryValue* source_dict; int source_id; int source_type; if (!event_params || @@ -118,13 +119,13 @@ bool NetLog::Source::FromEventParameters(Value* event_params, Source* source) { return true; } -Value* NetLog::Entry::ToValue() const { - DictionaryValue* entry_dict(new DictionaryValue()); +base::Value* NetLog::Entry::ToValue() const { + base::DictionaryValue* entry_dict(new base::DictionaryValue()); entry_dict->SetString("time", TickCountToString(time_)); // Set the entry source. - DictionaryValue* source_dict = new DictionaryValue(); + base::DictionaryValue* source_dict = new base::DictionaryValue(); source_dict->SetInteger("id", source_.id); source_dict->SetInteger("type", static_cast<int>(source_.type)); entry_dict->Set("source", source_dict); @@ -143,7 +144,7 @@ Value* NetLog::Entry::ToValue() const { return entry_dict; } -Value* NetLog::Entry::ParametersToValue() const { +base::Value* NetLog::Entry::ParametersToValue() const { if (parameters_callback_) return parameters_callback_->Run(log_level_); return NULL; @@ -299,7 +300,7 @@ const char* NetLog::EventTypeToString(EventType event) { // static base::Value* NetLog::GetEventTypesAsValue() { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); for (int i = 0; i < EVENT_COUNT; ++i) { dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i); } @@ -320,7 +321,7 @@ const char* NetLog::SourceTypeToString(SourceType source) { // static base::Value* NetLog::GetSourceTypesAsValue() { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); for (int i = 0; i < SOURCE_COUNT; ++i) { dict->SetInteger(SourceTypeToString(static_cast<SourceType>(i)), i); } diff --git a/net/base/net_util.cc b/net/base/net_util.cc index 75c6358..f4844f7 100644 --- a/net/base/net_util.cc +++ b/net/base/net_util.cc @@ -1939,7 +1939,7 @@ IPv6SupportResult::IPv6SupportResult(bool ipv6_supported, base::Value* IPv6SupportResult::ToNetLogValue( NetLog::LogLevel /* log_level */) const { - base::DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetBoolean("ipv6_supported", ipv6_supported); dict->SetString("ipv6_support_status", kFinalStatusNames[ipv6_support_status]); diff --git a/net/cert/crl_set.cc b/net/cert/crl_set.cc index a39cf5d..539fd6f 100644 --- a/net/cert/crl_set.cc +++ b/net/cert/crl_set.cc @@ -178,7 +178,7 @@ static bool ReadCRL(base::StringPiece* data, std::string* out_parent_spki_hash, } bool CRLSet::CopyBlockedSPKIsFromHeader(base::DictionaryValue* header_dict) { - ListValue* blocked_spkis_list = NULL; + base::ListValue* blocked_spkis_list = NULL; if (!header_dict->GetList("BlockedSPKIs", &blocked_spkis_list)) { // BlockedSPKIs is optional, so it's fine if we don't find it. return true; diff --git a/net/disk_cache/mem_entry_impl.cc b/net/disk_cache/mem_entry_impl.cc index dfd8ee6..7d00958 100644 --- a/net/disk_cache/mem_entry_impl.cc +++ b/net/disk_cache/mem_entry_impl.cc @@ -45,10 +45,11 @@ std::string GenerateChildName(const std::string& base_name, int child_id) { // Returns NetLog parameters for the creation of a child MemEntryImpl. Separate // function needed because child entries don't suppport GetKey(). -Value* NetLogChildEntryCreationCallback(const disk_cache::MemEntryImpl* parent, - int child_id, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogChildEntryCreationCallback( + const disk_cache::MemEntryImpl* parent, + int child_id, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("key", GenerateChildName(parent->GetKey(), child_id)); dict->SetBoolean("created", true); return dict; diff --git a/net/disk_cache/net_log_parameters.cc b/net/disk_cache/net_log_parameters.cc index 74ac2a2..5d7e50f 100644 --- a/net/disk_cache/net_log_parameters.cc +++ b/net/disk_cache/net_log_parameters.cc @@ -13,21 +13,23 @@ namespace { -Value* NetLogEntryCreationCallback(const disk_cache::Entry* entry, - bool created, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogEntryCreationCallback( + const disk_cache::Entry* entry, + bool created, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("key", entry->GetKey()); dict->SetBoolean("created", created); return dict; } -Value* NetLogReadWriteDataCallback(int index, - int offset, - int buf_len, - bool truncate, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogReadWriteDataCallback( + int index, + int offset, + int buf_len, + bool truncate, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("index", index); dict->SetInteger("offset", offset); dict->SetInteger("buf_len", buf_len); @@ -36,10 +38,11 @@ Value* NetLogReadWriteDataCallback(int index, return dict; } -Value* NetLogReadWriteCompleteCallback(int bytes_copied, - net::NetLog::LogLevel /* log_level */) { +base::Value* NetLogReadWriteCompleteCallback( + int bytes_copied, + net::NetLog::LogLevel /* log_level */) { DCHECK_NE(bytes_copied, net::ERR_IO_PENDING); - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); if (bytes_copied < 0) { dict->SetInteger("net_error", bytes_copied); } else { @@ -48,10 +51,11 @@ Value* NetLogReadWriteCompleteCallback(int bytes_copied, return dict; } -Value* NetLogSparseOperationCallback(int64 offset, - int buff_len, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSparseOperationCallback( + int64 offset, + int buff_len, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); // Values can only be created with at most 32-bit integers. Using a string // instead circumvents that restriction. dict->SetString("offset", base::Int64ToString(offset)); @@ -59,20 +63,21 @@ Value* NetLogSparseOperationCallback(int64 offset, return dict; } -Value* NetLogSparseReadWriteCallback(const net::NetLog::Source& source, - int child_len, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSparseReadWriteCallback( + const net::NetLog::Source& source, + int child_len, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); source.AddToEventParameters(dict); dict->SetInteger("child_len", child_len); return dict; } -Value* NetLogGetAvailableRangeResultCallback( +base::Value* NetLogGetAvailableRangeResultCallback( int64 start, int result, net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); if (result > 0) { dict->SetInteger("length", result); dict->SetString("start", base::Int64ToString(start)); diff --git a/net/dns/dns_transaction.cc b/net/dns/dns_transaction.cc index fef5f26..6d37710 100644 --- a/net/dns/dns_transaction.cc +++ b/net/dns/dns_transaction.cc @@ -57,10 +57,10 @@ bool IsIPLiteral(const std::string& hostname) { return ParseIPLiteralToNumber(hostname, &ip); } -Value* NetLogStartCallback(const std::string* hostname, +base::Value* NetLogStartCallback(const std::string* hostname, uint16 qtype, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("hostname", *hostname); dict->SetInteger("query_type", qtype); return dict; @@ -100,7 +100,7 @@ class DnsAttempt { Value* NetLogResponseCallback(NetLog::LogLevel log_level) const { DCHECK(GetResponse()->IsValid()); - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("rcode", GetResponse()->rcode()); dict->SetInteger("answer_count", GetResponse()->answer_count()); GetSocketNetLog().source().AddToEventParameters(dict); diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc index f0d10de..6c41181 100644 --- a/net/dns/host_resolver_impl.cc +++ b/net/dns/host_resolver_impl.cc @@ -275,7 +275,7 @@ base::Value* NetLogProcTaskFailedCallback(uint32 attempt_number, int net_error, int os_error, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); if (attempt_number) dict->SetInteger("attempt_number", attempt_number); @@ -308,7 +308,7 @@ base::Value* NetLogProcTaskFailedCallback(uint32 attempt_number, base::Value* NetLogDnsTaskFailedCallback(int net_error, int dns_error, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("net_error", net_error); if (dns_error) dict->SetInteger("dns_error", dns_error); @@ -320,7 +320,7 @@ base::Value* NetLogDnsTaskFailedCallback(int net_error, base::Value* NetLogRequestInfoCallback(const NetLog::Source& source, const HostResolver::RequestInfo* info, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); source.AddToEventParameters(dict); dict->SetString("host", info->host_port_pair().ToString()); @@ -336,7 +336,7 @@ base::Value* NetLogRequestInfoCallback(const NetLog::Source& source, base::Value* NetLogJobCreationCallback(const NetLog::Source& source, const std::string* host, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); source.AddToEventParameters(dict); dict->SetString("host", *host); return dict; @@ -346,7 +346,7 @@ base::Value* NetLogJobCreationCallback(const NetLog::Source& source, base::Value* NetLogJobAttachCallback(const NetLog::Source& source, RequestPriority priority, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); source.AddToEventParameters(dict); dict->SetInteger("priority", priority); return dict; @@ -1918,7 +1918,7 @@ base::Value* HostResolverImpl::GetDnsConfigAsValue() const { // for it. const DnsConfig* dns_config = dns_client_->GetConfig(); if (dns_config == NULL) - return new DictionaryValue(); + return new base::DictionaryValue(); return dns_config->ToValue(); } diff --git a/net/ftp/ftp_ctrl_response_buffer.cc b/net/ftp/ftp_ctrl_response_buffer.cc index 93c7715..f7b1467 100644 --- a/net/ftp/ftp_ctrl_response_buffer.cc +++ b/net/ftp/ftp_ctrl_response_buffer.cc @@ -79,12 +79,12 @@ int FtpCtrlResponseBuffer::ConsumeData(const char* data, int data_length) { namespace { -Value* NetLogFtpCtrlResponseCallback(const FtpCtrlResponse* response, - NetLog::LogLevel log_level) { - ListValue* lines = new ListValue(); +base::Value* NetLogFtpCtrlResponseCallback(const FtpCtrlResponse* response, + NetLog::LogLevel log_level) { + base::ListValue* lines = new base::ListValue(); lines->AppendStrings(response->lines); - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("status_code", response->status_code); dict->Set("lines", lines); return dict; diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc index 0ea7d94..4762c71 100644 --- a/net/http/http_network_session.cc +++ b/net/http/http_network_session.cc @@ -179,16 +179,16 @@ SSLClientSocketPool* HttpNetworkSession::GetSocketPoolForSSLWithProxy( proxy_server); } -Value* HttpNetworkSession::SocketPoolInfoToValue() const { +base::Value* HttpNetworkSession::SocketPoolInfoToValue() const { // TODO(yutak): Should merge values from normal pools and WebSocket pools. return normal_socket_pool_manager_->SocketPoolInfoToValue(); } -Value* HttpNetworkSession::SpdySessionPoolInfoToValue() const { +base::Value* HttpNetworkSession::SpdySessionPoolInfoToValue() const { return spdy_session_pool_.SpdySessionPoolInfoToValue(); } -Value* HttpNetworkSession::QuicInfoToValue() const { +base::Value* HttpNetworkSession::QuicInfoToValue() const { base::DictionaryValue* dict = new base::DictionaryValue(); dict->Set("sessions", quic_stream_factory_.QuicStreamFactoryInfoToValue()); dict->SetBoolean("quic_enabled", params_.enable_quic); diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc index efdd310..1cccbe5 100644 --- a/net/http/http_network_transaction.cc +++ b/net/http/http_network_transaction.cc @@ -96,12 +96,13 @@ bool IsClientCertificateError(int error) { } } -Value* NetLogSSLVersionFallbackCallback(const GURL* url, - int net_error, - uint16 version_before, - uint16 version_after, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSSLVersionFallbackCallback( + const GURL* url, + int net_error, + uint16 version_before, + uint16 version_after, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("host_and_port", GetHostAndPort(*url)); dict->SetInteger("net_error", net_error); dict->SetInteger("version_before", version_before); diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc index e2976f1..ffe23b2 100644 --- a/net/http/http_network_transaction_spdy2_unittest.cc +++ b/net/http/http_network_transaction_spdy2_unittest.cc @@ -122,10 +122,10 @@ int GetIdleSocketCountInSSLSocketPool(net::HttpNetworkSession* session) { // Takes in a Value created from a NetLogHttpResponseParameter, and returns // a JSONified list of headers as a single string. Uses single quotes instead // of double quotes for easier comparison. Returns false on failure. -bool GetHeaders(DictionaryValue* params, std::string* headers) { +bool GetHeaders(base::DictionaryValue* params, std::string* headers) { if (!params) return false; - ListValue* header_list; + base::ListValue* header_list; if (!params->GetList("headers", &header_list)) return false; std::string double_quote_headers; diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc index c4055c9..c33de98 100644 --- a/net/http/http_network_transaction_spdy3_unittest.cc +++ b/net/http/http_network_transaction_spdy3_unittest.cc @@ -133,10 +133,10 @@ HttpNetworkSession* CreateSession(SpdySessionDependencies* session_deps) { // Takes in a Value created from a NetLogHttpResponseParameter, and returns // a JSONified list of headers as a single string. Uses single quotes instead // of double quotes for easier comparison. Returns false on failure. -bool GetHeaders(DictionaryValue* params, std::string* headers) { +bool GetHeaders(base::DictionaryValue* params, std::string* headers) { if (!params) return false; - ListValue* header_list; + base::ListValue* header_list; if (!params->GetList("headers", &header_list)) return false; std::string double_quote_headers; diff --git a/net/http/http_pipelined_connection_impl.cc b/net/http/http_pipelined_connection_impl.cc index 471b26adef..b72f8e8 100644 --- a/net/http/http_pipelined_connection_impl.cc +++ b/net/http/http_pipelined_connection_impl.cc @@ -18,34 +18,31 @@ #include "net/http/http_version.h" #include "net/socket/client_socket_handle.h" -using base::DictionaryValue; -using base::Value; - namespace net { namespace { -Value* NetLogReceivedHeadersCallback(const NetLog::Source& source, - const std::string* feedback, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue; +base::Value* NetLogReceivedHeadersCallback(const NetLog::Source& source, + const std::string* feedback, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue; source.AddToEventParameters(dict); dict->SetString("feedback", *feedback); return dict; } -Value* NetLogStreamClosedCallback(const NetLog::Source& source, - bool not_reusable, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue; +base::Value* NetLogStreamClosedCallback(const NetLog::Source& source, + bool not_reusable, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue; source.AddToEventParameters(dict); dict->SetBoolean("not_reusable", not_reusable); return dict; } -Value* NetLogHostPortPairCallback(const HostPortPair* host_port_pair, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue; +base::Value* NetLogHostPortPairCallback(const HostPortPair* host_port_pair, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue; dict->SetString("host_and_port", host_port_pair->ToString()); return dict; } diff --git a/net/http/http_pipelined_host_forced.cc b/net/http/http_pipelined_host_forced.cc index 000936c..8179e86 100644 --- a/net/http/http_pipelined_host_forced.cc +++ b/net/http/http_pipelined_host_forced.cc @@ -10,10 +10,6 @@ #include "net/socket/buffered_write_stream_socket.h" #include "net/socket/client_socket_handle.h" -using base::DictionaryValue; -using base::ListValue; -using base::Value; - namespace net { HttpPipelinedHostForced::HttpPipelinedHostForced( @@ -89,10 +85,10 @@ void HttpPipelinedHostForced::OnPipelineFeedback( // We don't care. We always pipeline. } -Value* HttpPipelinedHostForced::PipelineInfoToValue() const { - ListValue* list_value = new ListValue(); +base::Value* HttpPipelinedHostForced::PipelineInfoToValue() const { + base::ListValue* list_value = new base::ListValue(); if (pipeline_.get()) { - DictionaryValue* pipeline_dict = new DictionaryValue; + base::DictionaryValue* pipeline_dict = new base::DictionaryValue; pipeline_dict->SetString("host", key_.origin().ToString()); pipeline_dict->SetBoolean("forced", true); pipeline_dict->SetInteger("depth", pipeline_->depth()); diff --git a/net/http/http_pipelined_host_impl.cc b/net/http/http_pipelined_host_impl.cc index 2c8238a..2a41ca4 100644 --- a/net/http/http_pipelined_host_impl.cc +++ b/net/http/http_pipelined_host_impl.cc @@ -9,10 +9,6 @@ #include "net/http/http_pipelined_connection_impl.h" #include "net/http/http_pipelined_stream.h" -using base::DictionaryValue; -using base::ListValue; -using base::Value; - namespace net { // TODO(simonjam): Run experiments to see what value minimizes evictions without @@ -190,11 +186,11 @@ void HttpPipelinedHostImpl::NotifyAllPipelinesHaveCapacity() { } } -Value* HttpPipelinedHostImpl::PipelineInfoToValue() const { - ListValue* list_value = new ListValue(); +base::Value* HttpPipelinedHostImpl::PipelineInfoToValue() const { + base::ListValue* list_value = new base::ListValue(); for (PipelineInfoMap::const_iterator it = pipelines_.begin(); it != pipelines_.end(); ++it) { - DictionaryValue* pipeline_dict = new DictionaryValue; + base::DictionaryValue* pipeline_dict = new base::DictionaryValue; pipeline_dict->SetString("host", key_.origin().ToString()); pipeline_dict->SetBoolean("forced", false); pipeline_dict->SetInteger("depth", it->first->depth()); diff --git a/net/http/http_pipelined_host_pool.cc b/net/http/http_pipelined_host_pool.cc index 7b00e7e..b8fec2a 100644 --- a/net/http/http_pipelined_host_pool.cc +++ b/net/http/http_pipelined_host_pool.cc @@ -12,9 +12,6 @@ #include "net/http/http_pipelined_host_impl.h" #include "net/http/http_server_properties.h" -using base::ListValue; -using base::Value; - namespace net { class HttpPipelinedHostImplFactory : public HttpPipelinedHost::Factory { @@ -135,11 +132,11 @@ void HttpPipelinedHostPool::OnHostDeterminedCapability( capability); } -Value* HttpPipelinedHostPool::PipelineInfoToValue() const { - ListValue* list = new ListValue(); +base::Value* HttpPipelinedHostPool::PipelineInfoToValue() const { + base::ListValue* list = new base::ListValue(); for (HostMap::const_iterator it = host_map_.begin(); it != host_map_.end(); ++it) { - Value* value = it->second->PipelineInfoToValue(); + base::Value* value = it->second->PipelineInfoToValue(); list->Append(value); } return list; diff --git a/net/http/http_proxy_client_socket_pool.cc b/net/http/http_proxy_client_socket_pool.cc index 4b4fabc..448c8fd 100644 --- a/net/http/http_proxy_client_socket_pool.cc +++ b/net/http/http_proxy_client_socket_pool.cc @@ -502,13 +502,13 @@ void HttpProxyClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) { base_.RemoveLayeredPool(layered_pool); } -DictionaryValue* HttpProxyClientSocketPool::GetInfoAsValue( +base::DictionaryValue* HttpProxyClientSocketPool::GetInfoAsValue( const std::string& name, const std::string& type, bool include_nested_pools) const { - DictionaryValue* dict = base_.GetInfoAsValue(name, type); + base::DictionaryValue* dict = base_.GetInfoAsValue(name, type); if (include_nested_pools) { - ListValue* list = new ListValue(); + base::ListValue* list = new base::ListValue(); if (transport_pool_) { list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool", "transport_socket_pool", diff --git a/net/http/http_request_headers.cc b/net/http/http_request_headers.cc index 15eee0c..bf557df 100644 --- a/net/http/http_request_headers.cc +++ b/net/http/http_request_headers.cc @@ -183,18 +183,18 @@ std::string HttpRequestHeaders::ToString() const { return output; } -Value* HttpRequestHeaders::NetLogCallback( +base::Value* HttpRequestHeaders::NetLogCallback( const std::string* request_line, NetLog::LogLevel /* log_level */) const { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("line", *request_line); - ListValue* headers = new ListValue(); + base::ListValue* headers = new base::ListValue(); for (HeaderVector::const_iterator it = headers_.begin(); it != headers_.end(); ++it) { headers->Append( - new StringValue(base::StringPrintf("%s: %s", - it->key.c_str(), - it->value.c_str()))); + new base::StringValue(base::StringPrintf("%s: %s", + it->key.c_str(), + it->value.c_str()))); } dict->Set("headers", headers); return dict; diff --git a/net/http/http_response_headers.cc b/net/http/http_response_headers.cc index 279149f..bffa004 100644 --- a/net/http/http_response_headers.cc +++ b/net/http/http_response_headers.cc @@ -1299,19 +1299,19 @@ bool HttpResponseHeaders::GetContentRange(int64* first_byte_position, return true; } -Value* HttpResponseHeaders::NetLogCallback( +base::Value* HttpResponseHeaders::NetLogCallback( NetLog::LogLevel /* log_level */) const { - DictionaryValue* dict = new DictionaryValue(); - ListValue* headers = new ListValue(); - headers->Append(new StringValue(GetStatusLine())); + base::DictionaryValue* dict = new base::DictionaryValue(); + base::ListValue* headers = new base::ListValue(); + headers->Append(new base::StringValue(GetStatusLine())); void* iterator = NULL; std::string name; std::string value; while (EnumerateHeaderLines(&iterator, &name, &value)) { headers->Append( - new StringValue(base::StringPrintf("%s: %s", - name.c_str(), - value.c_str()))); + new base::StringValue(base::StringPrintf("%s: %s", + name.c_str(), + value.c_str()))); } dict->Set("headers", headers); return dict; diff --git a/net/http/http_server_properties_impl.cc b/net/http/http_server_properties_impl.cc index 12f9847..f56dea8 100644 --- a/net/http/http_server_properties_impl.cc +++ b/net/http/http_server_properties_impl.cc @@ -81,7 +81,7 @@ void HttpServerPropertiesImpl::GetSpdyServerList( it != spdy_servers_table_.end(); ++it) { const std::string spdy_server_host_port = it->first; if (it->second) - spdy_server_list->Append(new StringValue(spdy_server_host_port)); + spdy_server_list->Append(new base::StringValue(spdy_server_host_port)); } } diff --git a/net/http/http_stream_factory_impl_job.cc b/net/http/http_stream_factory_impl_job.cc index 6bfef1e..179d8c4 100644 --- a/net/http/http_stream_factory_impl_job.cc +++ b/net/http/http_stream_factory_impl_job.cc @@ -42,11 +42,11 @@ namespace net { // Returns parameters associated with the start of a HTTP stream job. -Value* NetLogHttpStreamJobCallback(const GURL* original_url, - const GURL* url, - RequestPriority priority, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogHttpStreamJobCallback(const GURL* original_url, + const GURL* url, + RequestPriority priority, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("original_url", original_url->GetOrigin().spec()); dict->SetString("url", url->GetOrigin().spec()); dict->SetInteger("priority", priority); @@ -55,12 +55,12 @@ Value* NetLogHttpStreamJobCallback(const GURL* original_url, // Returns parameters associated with the Proto (with NPN negotiation) of a HTTP // stream. -Value* NetLogHttpStreamProtoCallback( +base::Value* NetLogHttpStreamProtoCallback( const SSLClientSocket::NextProtoStatus status, const std::string* proto, const std::string* server_protos, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("next_proto_status", SSLClientSocket::NextProtoStatusToString(status)); diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc index 4bec46f..e53aafd 100644 --- a/net/http/http_stream_parser.cc +++ b/net/http/http_stream_parser.cc @@ -56,11 +56,12 @@ bool HeadersContainMultipleCopiesOfField( return false; } -Value* NetLogSendRequestBodyCallback(int length, - bool is_chunked, - bool did_merge, - net::NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSendRequestBodyCallback( + int length, + bool is_chunked, + bool did_merge, + net::NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("length", length); dict->SetBoolean("is_chunked", is_chunked); dict->SetBoolean("did_merge", did_merge); diff --git a/net/proxy/proxy_script_decider.cc b/net/proxy/proxy_script_decider.cc index 942c195..38bf751 100644 --- a/net/proxy/proxy_script_decider.cc +++ b/net/proxy/proxy_script_decider.cc @@ -47,10 +47,10 @@ bool LooksLikePacScript(const base::string16& script) { // http://code.google.com/p/chromium/issues/detail?id=18575#c20 static const char kWpadUrl[] = "http://wpad/wpad.dat"; -Value* ProxyScriptDecider::PacSource::NetLogCallback( +base::Value* ProxyScriptDecider::PacSource::NetLogCallback( const GURL* effective_pac_url, NetLog::LogLevel /* log_level */) const { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); std::string source; switch (type) { case PacSource::WPAD_DHCP: diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc index f3e8e1c..d5bb42e 100644 --- a/net/quic/quic_client_session.cc +++ b/net/quic/quic_client_session.cc @@ -201,8 +201,8 @@ void QuicClientSession::CloseSessionOnError(int error) { stream_factory_->OnSessionClose(this); } -Value* QuicClientSession::GetInfoAsValue(const HostPortPair& pair) const { - DictionaryValue* dict = new DictionaryValue(); +base::Value* QuicClientSession::GetInfoAsValue(const HostPortPair& pair) const { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("host_port_pair", pair.ToString()); dict->SetInteger("open_streams", GetNumOpenStreams()); dict->SetInteger("total_streams", num_total_streams_); diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc index 5b33544..df3d6ac 100644 --- a/net/quic/quic_connection_logger.cc +++ b/net/quic/quic_connection_logger.cc @@ -14,20 +14,20 @@ namespace net { namespace { -Value* NetLogQuicPacketCallback(const IPEndPoint* self_address, - const IPEndPoint* peer_address, - size_t packet_size, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogQuicPacketCallback(const IPEndPoint* self_address, + const IPEndPoint* peer_address, + size_t packet_size, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("self_address", self_address->ToString()); dict->SetString("peer_address", peer_address->ToString()); dict->SetInteger("size", packet_size); return dict; } -Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("guid", base::Uint64ToString(header->public_header.guid)); dict->SetInteger("reset_flag", header->public_header.reset_flag); @@ -40,9 +40,9 @@ Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header, return dict; } -Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("stream_id", frame->stream_id); dict->SetBoolean("fin", frame->fin); dict->SetString("offset", base::Uint64ToString(frame->offset)); @@ -50,19 +50,19 @@ Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame, return dict; } -Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); - DictionaryValue* sent_info = new DictionaryValue(); +base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); + base::DictionaryValue* sent_info = new base::DictionaryValue(); dict->Set("sent_info", sent_info); sent_info->SetString("least_unacked", base::Uint64ToString(frame->sent_info.least_unacked)); - DictionaryValue* received_info = new DictionaryValue(); + base::DictionaryValue* received_info = new base::DictionaryValue(); dict->Set("received_info", received_info); received_info->SetString( "largest_observed", base::Uint64ToString(frame->received_info.largest_observed)); - ListValue* missing = new ListValue(); + base::ListValue* missing = new base::ListValue(); received_info->Set("missing_packets", missing); const SequenceNumberSet& missing_packets = frame->received_info.missing_packets; @@ -73,16 +73,16 @@ Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, return dict; } -Value* NetLogQuicCongestionFeedbackFrameCallback( +base::Value* NetLogQuicCongestionFeedbackFrameCallback( const QuicCongestionFeedbackFrame* frame, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); switch (frame->type) { case kInterArrival: { dict->SetString("type", "InterArrival"); dict->SetInteger("accumulated_number_of_lost_packets", frame->inter_arrival.accumulated_number_of_lost_packets); - ListValue* received = new ListValue(); + base::ListValue* received = new base::ListValue(); dict->Set("received_packets", received); for (TimeMap::const_iterator it = frame->inter_arrival.received_packet_times.begin(); @@ -109,19 +109,20 @@ Value* NetLogQuicCongestionFeedbackFrameCallback( return dict; } -Value* NetLogQuicRstStreamFrameCallback(const QuicRstStreamFrame* frame, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogQuicRstStreamFrameCallback( + const QuicRstStreamFrame* frame, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("stream_id", frame->stream_id); dict->SetInteger("error_code", frame->error_code); dict->SetString("details", frame->error_details); return dict; } -Value* NetLogQuicConnectionCloseFrameCallback( +base::Value* NetLogQuicConnectionCloseFrameCallback( const QuicConnectionCloseFrame* frame, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("error_code", frame->error_code); dict->SetString("details", frame->error_details); return dict; diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc index 7188290..8021f32 100644 --- a/net/socket/client_socket_pool_base_unittest.cc +++ b/net/socket/client_socket_pool_base_unittest.cc @@ -563,7 +563,7 @@ class TestClientSocketPool : public ClientSocketPool { base_.RemoveLayeredPool(pool); } - virtual DictionaryValue* GetInfoAsValue( + virtual base::DictionaryValue* GetInfoAsValue( const std::string& name, const std::string& type, bool include_nested_pools) const OVERRIDE { diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc index e8fabaa..b557874 100644 --- a/net/socket/client_socket_pool_manager_impl.cc +++ b/net/socket/client_socket_pool_manager_impl.cc @@ -19,7 +19,7 @@ namespace { // Appends information about all |socket_pools| to the end of |list|. template <class MapType> -void AddSocketPoolsToList(ListValue* list, +void AddSocketPoolsToList(base::ListValue* list, const MapType& socket_pools, const std::string& type, bool include_nested_pools) { @@ -341,8 +341,8 @@ SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSSLWithProxy( return ret.first->second; } -Value* ClientSocketPoolManagerImpl::SocketPoolInfoToValue() const { - ListValue* list = new ListValue(); +base::Value* ClientSocketPoolManagerImpl::SocketPoolInfoToValue() const { + base::ListValue* list = new base::ListValue(); list->Append(transport_socket_pool_->GetInfoAsValue("transport_socket_pool", "transport_socket_pool", false)); diff --git a/net/socket/nss_ssl_util.cc b/net/socket/nss_ssl_util.cc index 004f0ed..e6307af 100644 --- a/net/socket/nss_ssl_util.cc +++ b/net/socket/nss_ssl_util.cc @@ -226,12 +226,12 @@ int MapNSSError(PRErrorCode err) { // Returns parameters to attach to the NetLog when we receive an error in // response to a call to an NSS function. Used instead of // NetLogSSLErrorCallback with events of type TYPE_SSL_NSS_ERROR. -Value* NetLogSSLFailedNSSFunctionCallback( +base::Value* NetLogSSLFailedNSSFunctionCallback( const char* function, const char* param, int ssl_lib_error, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("function", function); if (param[0] != '\0') dict->SetString("param", param); diff --git a/net/socket/socket_net_log_params.cc b/net/socket/socket_net_log_params.cc index c075ec5..bcc12c8 100644 --- a/net/socket/socket_net_log_params.cc +++ b/net/socket/socket_net_log_params.cc @@ -14,33 +14,33 @@ namespace net { namespace { -Value* NetLogSocketErrorCallback(int net_error, - int os_error, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSocketErrorCallback(int net_error, + int os_error, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("net_error", net_error); dict->SetInteger("os_error", os_error); return dict; } -Value* NetLogHostPortPairCallback(const HostPortPair* host_and_port, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogHostPortPairCallback(const HostPortPair* host_and_port, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("host_and_port", host_and_port->ToString()); return dict; } -Value* NetLogIPEndPointCallback(const IPEndPoint* address, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogIPEndPointCallback(const IPEndPoint* address, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("address", address->ToString()); return dict; } -Value* NetLogSourceAddressCallback(const struct sockaddr* net_address, - socklen_t address_len, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSourceAddressCallback(const struct sockaddr* net_address, + socklen_t address_len, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("source_address", NetAddressToStringWithPort(net_address, address_len)); return dict; diff --git a/net/socket/socks_client_socket_pool.cc b/net/socket/socks_client_socket_pool.cc index 5e34cd0..ad541ce 100644 --- a/net/socket/socks_client_socket_pool.cc +++ b/net/socket/socks_client_socket_pool.cc @@ -276,13 +276,13 @@ void SOCKSClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) { base_.RemoveLayeredPool(layered_pool); } -DictionaryValue* SOCKSClientSocketPool::GetInfoAsValue( +base::DictionaryValue* SOCKSClientSocketPool::GetInfoAsValue( const std::string& name, const std::string& type, bool include_nested_pools) const { - DictionaryValue* dict = base_.GetInfoAsValue(name, type); + base::DictionaryValue* dict = base_.GetInfoAsValue(name, type); if (include_nested_pools) { - ListValue* list = new ListValue(); + base::ListValue* list = new base::ListValue(); list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool", "transport_socket_pool", false)); diff --git a/net/socket/ssl_client_socket_pool.cc b/net/socket/ssl_client_socket_pool.cc index e9b9ec5..b212b01 100644 --- a/net/socket/ssl_client_socket_pool.cc +++ b/net/socket/ssl_client_socket_pool.cc @@ -583,13 +583,13 @@ void SSLClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) { base_.RemoveLayeredPool(layered_pool); } -DictionaryValue* SSLClientSocketPool::GetInfoAsValue( +base::DictionaryValue* SSLClientSocketPool::GetInfoAsValue( const std::string& name, const std::string& type, bool include_nested_pools) const { - DictionaryValue* dict = base_.GetInfoAsValue(name, type); + base::DictionaryValue* dict = base_.GetInfoAsValue(name, type); if (include_nested_pools) { - ListValue* list = new ListValue(); + base::ListValue* list = new base::ListValue(); if (transport_pool_) { list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool", "transport_socket_pool", diff --git a/net/socket/ssl_error_params.cc b/net/socket/ssl_error_params.cc index 8fc381f..37561f0 100644 --- a/net/socket/ssl_error_params.cc +++ b/net/socket/ssl_error_params.cc @@ -11,10 +11,10 @@ namespace net { namespace { -Value* NetLogSSLErrorCallback(int net_error, - int ssl_lib_error, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSSLErrorCallback(int net_error, + int ssl_lib_error, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("net_error", net_error); if (ssl_lib_error) dict->SetInteger("ssl_lib_error", ssl_lib_error); diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc index b3ef53b..2989252 100644 --- a/net/socket/transport_client_socket_pool.cc +++ b/net/socket/transport_client_socket_pool.cc @@ -458,7 +458,7 @@ void TransportClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) { base_.RemoveLayeredPool(layered_pool); } -DictionaryValue* TransportClientSocketPool::GetInfoAsValue( +base::DictionaryValue* TransportClientSocketPool::GetInfoAsValue( const std::string& name, const std::string& type, bool include_nested_pools) const { diff --git a/net/spdy/spdy_header_block.cc b/net/spdy/spdy_header_block.cc index c84753a..ecc22a4 100644 --- a/net/spdy/spdy_header_block.cc +++ b/net/spdy/spdy_header_block.cc @@ -9,16 +9,16 @@ namespace net { -Value* SpdyHeaderBlockNetLogCallback( +base::Value* SpdyHeaderBlockNetLogCallback( const SpdyHeaderBlock* headers, NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); - DictionaryValue* headers_dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); + base::DictionaryValue* headers_dict = new base::DictionaryValue(); for (SpdyHeaderBlock::const_iterator it = headers->begin(); it != headers->end(); ++it) { headers_dict->SetWithoutPathExpansion( it->first, - new StringValue( + new base::StringValue( ShouldShowHttpHeaderValue(it->first) ? it->second : "[elided]")); } dict->Set("headers", headers_dict); diff --git a/net/spdy/spdy_network_transaction_spdy2_unittest.cc b/net/spdy/spdy_network_transaction_spdy2_unittest.cc index d71cee2..379603e 100644 --- a/net/spdy/spdy_network_transaction_spdy2_unittest.cc +++ b/net/spdy/spdy_network_transaction_spdy2_unittest.cc @@ -3780,7 +3780,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, NetLog) { net::NetLog::TYPE_SPDY_SESSION_SYN_STREAM, net::NetLog::PHASE_NONE); - ListValue* header_list; + base::ListValue* header_list; ASSERT_TRUE(entries[pos].params.get()); ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list)); diff --git a/net/spdy/spdy_network_transaction_spdy3_unittest.cc b/net/spdy/spdy_network_transaction_spdy3_unittest.cc index 13b372d..f0b7a12 100644 --- a/net/spdy/spdy_network_transaction_spdy3_unittest.cc +++ b/net/spdy/spdy_network_transaction_spdy3_unittest.cc @@ -4370,7 +4370,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, NetLog) { net::NetLog::TYPE_SPDY_SESSION_SYN_STREAM, net::NetLog::PHASE_NONE); - ListValue* header_list; + base::ListValue* header_list; ASSERT_TRUE(entries[pos].params.get()); ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list)); diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc index cda0102..499670e 100644 --- a/net/spdy/spdy_session_pool.cc +++ b/net/spdy/spdy_session_pool.cc @@ -251,8 +251,8 @@ bool SpdySessionPool::RemoveFromSessionList( return true; } -Value* SpdySessionPool::SpdySessionPoolInfoToValue() const { - ListValue* list = new ListValue(); +base::Value* SpdySessionPool::SpdySessionPoolInfoToValue() const { + base::ListValue* list = new base::ListValue(); for (SpdySessionsMap::const_iterator it = sessions_.begin(); it != sessions_.end(); ++it) { diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc index 9a144ce..190e175 100644 --- a/net/spdy/spdy_stream.cc +++ b/net/spdy/spdy_stream.cc @@ -21,22 +21,23 @@ namespace net { namespace { -Value* NetLogSpdyStreamErrorCallback(SpdyStreamId stream_id, - int status, - const std::string* description, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSpdyStreamErrorCallback(SpdyStreamId stream_id, + int status, + const std::string* description, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("stream_id", static_cast<int>(stream_id)); dict->SetInteger("status", status); dict->SetString("description", *description); return dict; } -Value* NetLogSpdyStreamWindowUpdateCallback(SpdyStreamId stream_id, - int32 delta, - int32 window_size, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogSpdyStreamWindowUpdateCallback( + SpdyStreamId stream_id, + int32 delta, + int32 window_size, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("stream_id", stream_id); dict->SetInteger("delta", delta); dict->SetInteger("window_size", window_size); diff --git a/net/test/spawned_test_server/local_test_server.cc b/net/test/spawned_test_server/local_test_server.cc index 375226a..34a6e66 100644 --- a/net/test/spawned_test_server/local_test_server.cc +++ b/net/test/spawned_test_server/local_test_server.cc @@ -198,7 +198,7 @@ bool LocalTestServer::AddCommandLineArguments(CommandLine* command_line) const { return false; // Serialize the argument dictionary into CommandLine. - for (DictionaryValue::Iterator it(arguments_dict); !it.IsAtEnd(); + for (base::DictionaryValue::Iterator it(arguments_dict); !it.IsAtEnd(); it.Advance()) { const base::Value& value = it.value(); const std::string& key = it.key(); diff --git a/net/test/spawned_test_server/spawner_communicator.cc b/net/test/spawned_test_server/spawner_communicator.cc index 83c5665..f3c2999 100644 --- a/net/test/spawned_test_server/spawner_communicator.cc +++ b/net/test/spawned_test_server/spawner_communicator.cc @@ -342,7 +342,8 @@ bool SpawnerCommunicator::StartServer(const std::string& arguments, } // Check whether spawner server returns valid data. - DictionaryValue* server_data = static_cast<DictionaryValue*>(value.get()); + base::DictionaryValue* server_data = + static_cast<base::DictionaryValue*>(value.get()); std::string message; if (!server_data->GetString("message", &message) || message != "started") { LOG(ERROR) << "Invalid message in server data: "; diff --git a/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc b/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc index 19091b7..e00c940 100644 --- a/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc +++ b/net/tools/dns_fuzz_stub/dns_fuzz_stub.cc @@ -64,7 +64,7 @@ bool ReadTestCase(const char* filename, return false; } - DictionaryValue* dict; + base::DictionaryValue* dict; if (!value->GetAsDictionary(&dict)) { LOG(ERROR) << filename << ": test case is not a dictionary."; return false; @@ -103,7 +103,7 @@ bool ReadTestCase(const char* filename, } *qtype = static_cast<uint16>(qtype_int); - ListValue* resp_list; + base::ListValue* resp_list; if (!dict->GetList("response", &resp_list)) { LOG(ERROR) << filename << ": response is missing or not a list."; return false; diff --git a/net/udp/udp_net_log_parameters.cc b/net/udp/udp_net_log_parameters.cc index a8642dd..c258823 100644 --- a/net/udp/udp_net_log_parameters.cc +++ b/net/udp/udp_net_log_parameters.cc @@ -13,11 +13,11 @@ namespace net { namespace { -Value* NetLogUDPDataTranferCallback(int byte_count, - const char* bytes, - const IPEndPoint* address, - NetLog::LogLevel log_level) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogUDPDataTranferCallback(int byte_count, + const char* bytes, + const IPEndPoint* address, + NetLog::LogLevel log_level) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("byte_count", byte_count); if (NetLog::IsLoggingBytes(log_level)) dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count)); @@ -26,9 +26,9 @@ Value* NetLogUDPDataTranferCallback(int byte_count, return dict; } -Value* NetLogUDPConnectCallback(const IPEndPoint* address, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogUDPConnectCallback(const IPEndPoint* address, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("address", address->ToString()); return dict; } diff --git a/net/url_request/url_request_netlog_params.cc b/net/url_request/url_request_netlog_params.cc index 230517c..3e26eec 100644 --- a/net/url_request/url_request_netlog_params.cc +++ b/net/url_request/url_request_netlog_params.cc @@ -10,13 +10,13 @@ namespace net { -Value* NetLogURLRequestStartCallback(const GURL* url, - const std::string* method, - int load_flags, - RequestPriority priority, - int64 upload_id, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogURLRequestStartCallback(const GURL* url, + const std::string* method, + int load_flags, + RequestPriority priority, + int64 upload_id, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("url", url->possibly_invalid_spec()); dict->SetString("method", *method); dict->SetInteger("load_flags", load_flags); @@ -28,7 +28,7 @@ Value* NetLogURLRequestStartCallback(const GURL* url, bool StartEventLoadFlagsFromEventParams(const Value* event_params, int* load_flags) { - const DictionaryValue* dict; + const base::DictionaryValue* dict; if (!event_params->GetAsDictionary(&dict) || !dict->GetInteger("load_flags", load_flags)) { *load_flags = 0; diff --git a/net/url_request/url_request_throttler_entry.cc b/net/url_request/url_request_throttler_entry.cc index 69f0a4d..b7c0612 100644 --- a/net/url_request/url_request_throttler_entry.cc +++ b/net/url_request/url_request_throttler_entry.cc @@ -52,11 +52,11 @@ const char URLRequestThrottlerEntry::kExponentialThrottlingDisableValue[] = "disable"; // Returns NetLog parameters when a request is rejected by throttling. -Value* NetLogRejectedRequestCallback(const std::string* url_id, - int num_failures, - int release_after_ms, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); +base::Value* NetLogRejectedRequestCallback(const std::string* url_id, + int num_failures, + int release_after_ms, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetString("url", *url_id); dict->SetInteger("num_failures", num_failures); dict->SetInteger("release_after_ms", release_after_ms); diff --git a/net/websockets/websocket_net_log_params.cc b/net/websockets/websocket_net_log_params.cc index f2b33b1..dd9bdde 100644 --- a/net/websockets/websocket_net_log_params.cc +++ b/net/websockets/websocket_net_log_params.cc @@ -9,10 +9,11 @@ namespace net { -Value* NetLogWebSocketHandshakeCallback(const std::string* headers, - NetLog::LogLevel /* log_level */) { - DictionaryValue* dict = new DictionaryValue(); - ListValue* header_list = new ListValue(); +base::Value* NetLogWebSocketHandshakeCallback( + const std::string* headers, + NetLog::LogLevel /* log_level */) { + base::DictionaryValue* dict = new base::DictionaryValue(); + base::ListValue* header_list = new base::ListValue(); size_t last = 0; size_t headers_size = headers->size(); @@ -25,7 +26,7 @@ Value* NetLogWebSocketHandshakeCallback(const std::string* headers, pos += 2; last = pos; - header_list->Append(new StringValue(entry)); + header_list->Append(new base::StringValue(entry)); if (entry.empty()) { // Dump WebSocket key3. @@ -33,7 +34,7 @@ Value* NetLogWebSocketHandshakeCallback(const std::string* headers, for (; pos < headers_size; ++pos) { key += base::StringPrintf("\\x%02x", (*headers)[pos] & 0xff); } - header_list->Append(new StringValue(key)); + header_list->Append(new base::StringValue(key)); break; } } else { diff --git a/net/websockets/websocket_net_log_params_unittest.cc b/net/websockets/websocket_net_log_params_unittest.cc index 0519390f..b1c9857 100644 --- a/net/websockets/websocket_net_log_params_unittest.cc +++ b/net/websockets/websocket_net_log_params_unittest.cc @@ -12,19 +12,21 @@ #include "testing/gtest/include/gtest/gtest.h" TEST(NetLogWebSocketHandshakeParameterTest, ToValue) { - ListValue* list = new ListValue(); - list->Append(new StringValue("GET /demo HTTP/1.1")); - list->Append(new StringValue("Host: example.com")); - list->Append(new StringValue("Connection: Upgrade")); - list->Append(new StringValue("Sec-WebSocket-Key2: 12998 5 Y3 1 .P00")); - list->Append(new StringValue("Sec-WebSocket-Protocol: sample")); - list->Append(new StringValue("Upgrade: WebSocket")); - list->Append(new StringValue("Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5")); - list->Append(new StringValue("Origin: http://example.com")); - list->Append(new StringValue(std::string())); - list->Append(new StringValue("\\x00\\x01\\x0a\\x0d\\xff\\xfe\\x0d\\x0a")); - - DictionaryValue expected; + base::ListValue* list = new base::ListValue(); + list->Append(new base::StringValue("GET /demo HTTP/1.1")); + list->Append(new base::StringValue("Host: example.com")); + list->Append(new base::StringValue("Connection: Upgrade")); + list->Append(new base::StringValue("Sec-WebSocket-Key2: 12998 5 Y3 1 .P00")); + list->Append(new base::StringValue("Sec-WebSocket-Protocol: sample")); + list->Append(new base::StringValue("Upgrade: WebSocket")); + list->Append(new base::StringValue( + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5")); + list->Append(new base::StringValue("Origin: http://example.com")); + list->Append(new base::StringValue(std::string())); + list->Append(new base::StringValue( + "\\x00\\x01\\x0a\\x0d\\xff\\xfe\\x0d\\x0a")); + + base::DictionaryValue expected; expected.Set("headers", list); const std::string key("\x00\x01\x0a\x0d\xff\xfe\x0d\x0a", 8); @@ -40,7 +42,7 @@ TEST(NetLogWebSocketHandshakeParameterTest, ToValue) { "\r\n" + key; - scoped_ptr<Value> actual( + scoped_ptr<base::Value> actual( net::NetLogWebSocketHandshakeCallback(&testInput, net::NetLog::LOG_BASIC)); |