Remove //net (except for Android test stuff) and sdch

net/base/net_log_util.cc

Index: net/base/net_log_util.cc
diff --git a/net/base/net_log_util.cc b/net/base/net_log_util.cc
deleted file mode 100644
index 75be128851425df39202c8ab91a839427e28904d..0000000000000000000000000000000000000000
--- a/net/base/net_log_util.cc
+++ /dev/null
@@ -1,565 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/base/net_log_util.h"
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/metrics/field_trial.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "base/time/time.h"
-#include "base/values.h"
-#include "net/base/address_family.h"
-#include "net/base/load_states.h"
-#include "net/base/net_errors.h"
-#include "net/base/net_log.h"
-#include "net/base/sdch_manager.h"
-#include "net/disk_cache/disk_cache.h"
-#include "net/dns/host_cache.h"
-#include "net/dns/host_resolver.h"
-#include "net/http/http_cache.h"
-#include "net/http/http_network_session.h"
-#include "net/http/http_server_properties.h"
-#include "net/http/http_transaction_factory.h"
-#include "net/proxy/proxy_config.h"
-#include "net/proxy/proxy_retry_info.h"
-#include "net/proxy/proxy_service.h"
-#include "net/quic/quic_protocol.h"
-#include "net/quic/quic_utils.h"
-#include "net/socket/ssl_client_socket.h"
-#include "net/url_request/url_request.h"
-#include "net/url_request/url_request_context.h"
-
-namespace net {
-
-namespace {
-
-// This should be incremented when significant changes are made that will
-// invalidate the old loading code.
-const int kLogFormatVersion = 1;
-
-struct StringToConstant {
-  const char* name;
-  const int constant;
-};
-
-const StringToConstant kCertStatusFlags[] = {
-#define CERT_STATUS_FLAG(label, value) { #label, value },
-#include "net/cert/cert_status_flags_list.h"
-#undef CERT_STATUS_FLAG
-};
-
-const StringToConstant kLoadFlags[] = {
-#define LOAD_FLAG(label, value) { #label, value },
-#include "net/base/load_flags_list.h"
-#undef LOAD_FLAG
-};
-
-const StringToConstant kLoadStateTable[] = {
-#define LOAD_STATE(label) { # label, net::LOAD_STATE_ ## label },
-#include "net/base/load_states_list.h"
-#undef LOAD_STATE
-};
-
-const short kNetErrors[] = {
-#define NET_ERROR(label, value) value,
-#include "net/base/net_error_list.h"
-#undef NET_ERROR
-};
-
-const StringToConstant kSdchProblems[] = {
-#define SDCH_PROBLEM_CODE(label, value) \
-  { #label, value }                     \
-  ,
-#include "net/base/sdch_problem_code_list.h"
-#undef SDCH_PROBLEM_CODE
-};
-
-const char* NetInfoSourceToString(NetInfoSource source) {
-  switch (source) {
-    #define NET_INFO_SOURCE(label, string, value) \
-    case NET_INFO_ ## label: \
-      return string;
-#include "net/base/net_info_source_list.h"
-    #undef NET_INFO_SOURCE
-    case NET_INFO_ALL_SOURCES:
-      return "All";
-  }
-  return "?";
-}
-
-// Returns the disk cache backend for |context| if there is one, or NULL.
-// Despite the name, can return an in memory "disk cache".
-disk_cache::Backend* GetDiskCacheBackend(net::URLRequestContext* context) {
-  if (!context->http_transaction_factory())
-    return NULL;
-
-  net::HttpCache* http_cache = context->http_transaction_factory()->GetCache();
-  if (!http_cache)
-    return NULL;
-
-  return http_cache->GetCurrentBackend();
-}
-
-// Returns true if |request1| was created before |request2|.
-bool RequestCreatedBefore(const net::URLRequest* request1,
-                          const net::URLRequest* request2) {
-  if (request1->creation_time() < request2->creation_time())
-    return true;
-  if (request1->creation_time() > request2->creation_time())
-    return false;
-  // If requests were created at the same time, sort by ID.  Mostly matters for
-  // testing purposes.
-  return request1->identifier() < request2->identifier();
-}
-
-// Returns a Value representing the state of a pre-existing URLRequest when
-// net-internals was opened.
-base::Value* GetRequestStateAsValue(const net::URLRequest* request,
-                                    net::NetLog::LogLevel log_level) {
-  return request->GetStateAsValue();
-}
-
-}  // namespace
-
-scoped_ptr<base::DictionaryValue> GetNetConstants() {
-  scoped_ptr<base::DictionaryValue> constants_dict(new base::DictionaryValue());
-
-  // Version of the file format.
-  constants_dict->SetInteger("logFormatVersion", kLogFormatVersion);
-
-  // Add a dictionary with information on the relationship between event type
-  // enums and their symbolic names.
-  constants_dict->Set("logEventTypes", net::NetLog::GetEventTypesAsValue());
-
-  // Add a dictionary with information about the relationship between CertStatus
-  // flags and their symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (size_t i = 0; i < arraysize(kCertStatusFlags); i++)
-      dict->SetInteger(kCertStatusFlags[i].name, kCertStatusFlags[i].constant);
-
-    constants_dict->Set("certStatusFlag", dict);
-  }
-
-  // Add a dictionary with information about the relationship between load flag
-  // enums and their symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (size_t i = 0; i < arraysize(kLoadFlags); i++)
-      dict->SetInteger(kLoadFlags[i].name, kLoadFlags[i].constant);
-
-    constants_dict->Set("loadFlag", dict);
-  }
-
-  // Add a dictionary with information about the relationship between load state
-  // enums and their symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (size_t i = 0; i < arraysize(kLoadStateTable); i++)
-      dict->SetInteger(kLoadStateTable[i].name, kLoadStateTable[i].constant);
-
-    constants_dict->Set("loadState", dict);
-  }
-
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-    #define NET_INFO_SOURCE(label, string, value) \
-        dict->SetInteger(string, NET_INFO_ ## label);
-#include "net/base/net_info_source_list.h"
-    #undef NET_INFO_SOURCE
-    constants_dict->Set("netInfoSources", dict);
-  }
-
-  // Add information on the relationship between net error codes and their
-  // symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (size_t i = 0; i < arraysize(kNetErrors); i++)
-      dict->SetInteger(ErrorToShortString(kNetErrors[i]), kNetErrors[i]);
-
-    constants_dict->Set("netError", dict);
-  }
-
-  // Add information on the relationship between QUIC error codes and their
-  // symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (net::QuicErrorCode error = net::QUIC_NO_ERROR;
-         error < net::QUIC_LAST_ERROR;
-         error = static_cast<net::QuicErrorCode>(error + 1)) {
-      dict->SetInteger(net::QuicUtils::ErrorToString(error),
-                       static_cast<int>(error));
-    }
-
-    constants_dict->Set("quicError", dict);
-  }
-
-  // Add information on the relationship between QUIC RST_STREAM error codes
-  // and their symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (net::QuicRstStreamErrorCode error = net::QUIC_STREAM_NO_ERROR;
-         error < net::QUIC_STREAM_LAST_ERROR;
-         error = static_cast<net::QuicRstStreamErrorCode>(error + 1)) {
-      dict->SetInteger(net::QuicUtils::StreamErrorToString(error),
-                       static_cast<int>(error));
-    }
-
-    constants_dict->Set("quicRstStreamError", dict);
-  }
-
-  // Add information on the relationship between SDCH problem codes and their
-  // symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    for (size_t i = 0; i < arraysize(kSdchProblems); i++)
-      dict->SetInteger(kSdchProblems[i].name, kSdchProblems[i].constant);
-
-    constants_dict->Set("sdchProblemCode", dict);
-  }
-
-  // Information about the relationship between event phase enums and their
-  // symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    dict->SetInteger("PHASE_BEGIN", net::NetLog::PHASE_BEGIN);
-    dict->SetInteger("PHASE_END", net::NetLog::PHASE_END);
-    dict->SetInteger("PHASE_NONE", net::NetLog::PHASE_NONE);
-
-    constants_dict->Set("logEventPhase", dict);
-  }
-
-  // Information about the relationship between source type enums and
-  // their symbolic names.
-  constants_dict->Set("logSourceType", net::NetLog::GetSourceTypesAsValue());
-
-  // Information about the relationship between LogLevel enums and their
-  // symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    dict->SetInteger("LOG_ALL", net::NetLog::LOG_ALL);
-    dict->SetInteger("LOG_ALL_BUT_BYTES", net::NetLog::LOG_ALL_BUT_BYTES);
-    dict->SetInteger("LOG_STRIP_PRIVATE_DATA",
-                     net::NetLog::LOG_STRIP_PRIVATE_DATA);
-
-    constants_dict->Set("logLevelType", dict);
-  }
-
-  // Information about the relationship between address family enums and
-  // their symbolic names.
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-
-    dict->SetInteger("ADDRESS_FAMILY_UNSPECIFIED",
-                     net::ADDRESS_FAMILY_UNSPECIFIED);
-    dict->SetInteger("ADDRESS_FAMILY_IPV4",
-                     net::ADDRESS_FAMILY_IPV4);
-    dict->SetInteger("ADDRESS_FAMILY_IPV6",
-                     net::ADDRESS_FAMILY_IPV6);
-
-    constants_dict->Set("addressFamily", dict);
-  }
-
-  // Information about how the "time ticks" values we have given it relate to
-  // actual system times. (We used time ticks throughout since they are stable
-  // across system clock changes).
-  {
-    int64 cur_time_ms = (base::Time::Now() - base::Time()).InMilliseconds();
-
-    int64 cur_time_ticks_ms =
-        (base::TimeTicks::Now() - base::TimeTicks()).InMilliseconds();
-
-    // If we add this number to a time tick value, it gives the timestamp.
-    int64 tick_to_time_ms = cur_time_ms - cur_time_ticks_ms;
-
-    // Chrome on all platforms stores times using the Windows epoch
-    // (Jan 1 1601), but the javascript wants a unix epoch.
-    // TODO(eroman): Getting the timestamp relative to the unix epoch should
-    //               be part of the time library.
-    const int64 kUnixEpochMs = 11644473600000LL;
-    int64 tick_to_unix_time_ms = tick_to_time_ms - kUnixEpochMs;
-
-    // Pass it as a string, since it may be too large to fit in an integer.
-    constants_dict->SetString("timeTickOffset",
-                              base::Int64ToString(tick_to_unix_time_ms));
-  }
-
-  // "clientInfo" key is required for some NetLogLogger log readers.
-  // Provide a default empty value for compatibility.
-  constants_dict->Set("clientInfo", new base::DictionaryValue());
-
-  // Add a list of active field experiments.
-  {
-    base::FieldTrial::ActiveGroups active_groups;
-    base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-    base::ListValue* field_trial_groups = new base::ListValue();
-    for (base::FieldTrial::ActiveGroups::const_iterator it =
-             active_groups.begin();
-         it != active_groups.end(); ++it) {
-      field_trial_groups->AppendString(it->trial_name + ":" +
-                                       it->group_name);
-    }
-    constants_dict->Set("activeFieldTrialGroups", field_trial_groups);
-  }
-
-  return constants_dict.Pass();
-}
-
-NET_EXPORT scoped_ptr<base::DictionaryValue> GetNetInfo(
-    URLRequestContext* context, int info_sources) {
-  // May only be called on the context's thread.
-  DCHECK(context->CalledOnValidThread());
-
-  scoped_ptr<base::DictionaryValue> net_info_dict(new base::DictionaryValue());
-
-  // TODO(mmenke):  The code for most of these sources should probably be moved
-  // into the sources themselves.
-  if (info_sources & NET_INFO_PROXY_SETTINGS) {
-    net::ProxyService* proxy_service = context->proxy_service();
-
-    base::DictionaryValue* dict = new base::DictionaryValue();
-    if (proxy_service->fetched_config().is_valid())
-      dict->Set("original", proxy_service->fetched_config().ToValue());
-    if (proxy_service->config().is_valid())
-      dict->Set("effective", proxy_service->config().ToValue());
-
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_PROXY_SETTINGS), dict);
-  }
-
-  if (info_sources & NET_INFO_BAD_PROXIES) {
-    const net::ProxyRetryInfoMap& bad_proxies_map =
-        context->proxy_service()->proxy_retry_info();
-
-    base::ListValue* list = new base::ListValue();
-
-    for (net::ProxyRetryInfoMap::const_iterator it = bad_proxies_map.begin();
-         it != bad_proxies_map.end(); ++it) {
-      const std::string& proxy_uri = it->first;
-      const net::ProxyRetryInfo& retry_info = it->second;
-
-      base::DictionaryValue* dict = new base::DictionaryValue();
-      dict->SetString("proxy_uri", proxy_uri);
-      dict->SetString("bad_until",
-                      net::NetLog::TickCountToString(retry_info.bad_until));
-
-      list->Append(dict);
-    }
-
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_BAD_PROXIES), list);
-  }
-
-  if (info_sources & NET_INFO_HOST_RESOLVER) {
-    net::HostResolver* host_resolver = context->host_resolver();
-    DCHECK(host_resolver);
-    net::HostCache* cache = host_resolver->GetHostCache();
-    if (cache) {
-      base::DictionaryValue* dict = new base::DictionaryValue();
-      base::Value* dns_config = host_resolver->GetDnsConfigAsValue();
-      if (dns_config)
-        dict->Set("dns_config", dns_config);
-
-      dict->SetInteger(
-          "default_address_family",
-          static_cast<int>(host_resolver->GetDefaultAddressFamily()));
-
-      base::DictionaryValue* cache_info_dict = new base::DictionaryValue();
-
-      cache_info_dict->SetInteger(
-          "capacity",
-          static_cast<int>(cache->max_entries()));
-
-      base::ListValue* entry_list = new base::ListValue();
-
-      net::HostCache::EntryMap::Iterator it(cache->entries());
-      for (; it.HasNext(); it.Advance()) {
-        const net::HostCache::Key& key = it.key();
-        const net::HostCache::Entry& entry = it.value();
-
-        base::DictionaryValue* entry_dict = new base::DictionaryValue();
-
-        entry_dict->SetString("hostname", key.hostname);
-        entry_dict->SetInteger("address_family",
-            static_cast<int>(key.address_family));
-        entry_dict->SetString("expiration",
-                              net::NetLog::TickCountToString(it.expiration()));
-
-        if (entry.error != net::OK) {
-          entry_dict->SetInteger("error", entry.error);
-        } else {
-          // Append all of the resolved addresses.
-          base::ListValue* address_list = new base::ListValue();
-          for (size_t i = 0; i < entry.addrlist.size(); ++i) {
-            address_list->AppendString(entry.addrlist[i].ToStringWithoutPort());
-          }
-          entry_dict->Set("addresses", address_list);
-        }
-
-        entry_list->Append(entry_dict);
-      }
-
-      cache_info_dict->Set("entries", entry_list);
-      dict->Set("cache", cache_info_dict);
-      net_info_dict->Set(NetInfoSourceToString(NET_INFO_HOST_RESOLVER), dict);
-    }
-  }
-
-  net::HttpNetworkSession* http_network_session =
-      context->http_transaction_factory()->GetSession();
-
-  if (info_sources & NET_INFO_SOCKET_POOL) {
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_SOCKET_POOL),
-                        http_network_session->SocketPoolInfoToValue());
-  }
-
-  if (info_sources & NET_INFO_SPDY_SESSIONS) {
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_SESSIONS),
-                        http_network_session->SpdySessionPoolInfoToValue());
-  }
-
-  if (info_sources & NET_INFO_SPDY_STATUS) {
-    base::DictionaryValue* status_dict = new base::DictionaryValue();
-
-    status_dict->SetBoolean("spdy_enabled",
-                            net::HttpStreamFactory::spdy_enabled());
-    status_dict->SetBoolean(
-        "use_alternate_protocols",
-        http_network_session->params().use_alternate_protocols);
-    status_dict->SetBoolean(
-        "force_spdy_over_ssl",
-        http_network_session->params().force_spdy_over_ssl);
-    status_dict->SetBoolean(
-        "force_spdy_always",
-        http_network_session->params().force_spdy_always);
-
-    NextProtoVector next_protos;
-    http_network_session->GetNextProtos(&next_protos);
-    if (!next_protos.empty()) {
-      std::string next_protos_string;
-      for (const NextProto proto : next_protos) {
-        if (!next_protos_string.empty())
-          next_protos_string.append(",");
-        next_protos_string.append(SSLClientSocket::NextProtoToString(proto));
-      }
-      status_dict->SetString("next_protos", next_protos_string);
-    }
-
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_STATUS),
-                        status_dict);
-  }
-
-  if (info_sources & NET_INFO_SPDY_ALT_PROTO_MAPPINGS) {
-    base::ListValue* dict_list = new base::ListValue();
-
-    const net::HttpServerProperties& http_server_properties =
-        *context->http_server_properties();
-
-    const net::AlternateProtocolMap& map =
-        http_server_properties.alternate_protocol_map();
-
-    for (net::AlternateProtocolMap::const_iterator it = map.begin();
-          it != map.end(); ++it) {
-      base::DictionaryValue* dict = new base::DictionaryValue();
-      dict->SetString("host_port_pair", it->first.ToString());
-      dict->SetString("alternate_protocol", it->second.ToString());
-      dict_list->Append(dict);
-    }
-
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_ALT_PROTO_MAPPINGS),
-                       dict_list);
-  }
-
-  if (info_sources & NET_INFO_QUIC) {
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_QUIC),
-                        http_network_session->QuicInfoToValue());
-  }
-
-  if (info_sources & NET_INFO_HTTP_CACHE) {
-    base::DictionaryValue* info_dict = new base::DictionaryValue();
-    base::DictionaryValue* stats_dict = new base::DictionaryValue();
-
-    disk_cache::Backend* disk_cache = GetDiskCacheBackend(context);
-
-    if (disk_cache) {
-      // Extract the statistics key/value pairs from the backend.
-      base::StringPairs stats;
-      disk_cache->GetStats(&stats);
-      for (size_t i = 0; i < stats.size(); ++i) {
-        stats_dict->SetStringWithoutPathExpansion(
-            stats[i].first, stats[i].second);
-      }
-    }
-    info_dict->Set("stats", stats_dict);
-
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_HTTP_CACHE),
-                       info_dict);
-  }
-
-  if (info_sources & NET_INFO_SDCH) {
-    base::Value* info_dict;
-    SdchManager* sdch_manager = context->sdch_manager();
-    if (sdch_manager) {
-      info_dict = sdch_manager->SdchInfoToValue();
-    } else {
-      info_dict = new base::DictionaryValue();
-    }
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_SDCH), info_dict);
-  }
-
-  return net_info_dict.Pass();
-}
-
-NET_EXPORT void CreateNetLogEntriesForActiveObjects(
-    const std::set<URLRequestContext*>& contexts,
-    NetLog::ThreadSafeObserver* observer) {
-  // Not safe to call this when the observer is watching a NetLog.
-  DCHECK(!observer->net_log());
-
-  // Put together the list of all requests.
-  std::vector<const URLRequest*> requests;
-  for (const auto& context : contexts) {
-    // May only be called on the context's thread.
-    DCHECK(context->CalledOnValidThread());
-    // Contexts should all be using the same NetLog.
-    DCHECK_EQ((*contexts.begin())->net_log(), context->net_log());
-    for (const auto& request : *context->url_requests()) {
-      requests.push_back(request);
-    }
-  }
-
-  // Sort by creation time.
-  std::sort(requests.begin(), requests.end(), RequestCreatedBefore);
-
-  // Create fake events.
-  ScopedVector<NetLog::Entry> entries;
-  for (const auto& request : requests) {
-    net::NetLog::ParametersCallback callback =
-        base::Bind(&GetRequestStateAsValue, base::Unretained(request));
-
-    net::NetLog::EntryData entry_data(net::NetLog::TYPE_REQUEST_ALIVE,
-                                      request->net_log().source(),
-                                      net::NetLog::PHASE_BEGIN,
-                                      request->creation_time(),
-                                      &callback);
-    NetLog::Entry entry(&entry_data, request->net_log().GetLogLevel());
-    observer->OnAddEntry(entry);
-  }
-}
-
-}  // namespace net