Rename PrivateMode enum values:

kPrivacyModeDisabled => PRIVACY_MODE_DISABLED
kPrivacyModeEnabled  => PRIVACY_MODE_ENABLED

To match the chromium style guide:

Though the Google C++ Style Guide now says to use kConstantNaming for enums,
Chromium was written using MACRO_STYLE naming.  Continue to use this style for consistency.

R=mef@chromium.org

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=260281

Review URL: https://codereview.chromium.org/215023002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260729 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/net/preconnect.cc

@@ -69,7 +69,7 @@ void PreconnectOnIOThread(
 
   net::NetworkDelegate* delegate = context->network_delegate();
   if (delegate->CanEnablePrivacyMode(url, first_party_for_cookies))
-    request_info.privacy_mode = net::kPrivacyModeEnabled;
+    request_info.privacy_mode = net::PRIVACY_MODE_ENABLED;
 
   // It almost doesn't matter whether we use net::LOWEST or net::HIGHEST
   // priority here, as we won't make a request, and will surrender the created

google_apis/gcm/engine/connection_factory_impl.cc

@@ -376,7 +376,7 @@ void ConnectionFactoryImpl::OnProxyResolveDone(int status) {
       proxy_info_,
       ssl_config,
       ssl_config,
-      net::kPrivacyModeDisabled,
+      net::PRIVACY_MODE_DISABLED,
       bound_net_log_,
       &socket_handle_,
       base::Bind(&ConnectionFactoryImpl::OnConnectDone,

jingle/glue/proxy_resolving_client_socket.cc

@@ -192,7 +192,7 @@ void ProxyResolvingClientSocket::ProcessProxyResolveDone(int status) {
   // Now that we have resolved the proxy, we need to connect.
   status = net::InitSocketHandleForRawConnect(
       dest_host_port_pair_, network_session_.get(), proxy_info_, ssl_config_,
-      ssl_config_, net::kPrivacyModeDisabled, bound_net_log_, transport_.get(),
+      ssl_config_, net::PRIVACY_MODE_DISABLED, bound_net_log_, transport_.get(),
       connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     // Since this method is always called asynchronously. it is OK to call

net/base/privacy_mode.h

@@ -10,11 +10,10 @@ namespace net {
 // Privacy Mode is enabled if cookies to particular site are blocked, so
 // Channel ID is disabled on that connection (https or spdy).
 enum PrivacyMode {
-  kPrivacyModeDisabled = 0,
-  kPrivacyModeEnabled = 1,
+  PRIVACY_MODE_DISABLED = 0,
+  PRIVACY_MODE_ENABLED = 1,
 };
 
 };  // namespace net
 
 #endif  // NET_BASE_PRIVACY_MODE_H_
-

net/http/disk_cache_based_quic_server_info_unittest.cc

@@ -58,7 +58,7 @@ TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   MockHttpCache cache(factory);
   QuicSessionKey server_key("www.verisign.com", 443, true,
-                            kPrivacyModeDisabled);
+                            PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_key, cache.http_cache()));
   quic_server_info->Start();
@@ -76,7 +76,7 @@ TEST(DiskCacheBasedQuicServerInfo, Update) {
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
-  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_key, cache.http_cache()));
   quic_server_info->Start();
@@ -143,7 +143,8 @@ TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
   TestCompletionCallback callback;
 
   // Persist data for port 443.
-  QuicSessionKey server_key1("www.google.com", 443, true, kPrivacyModeDisabled);
+  QuicSessionKey server_key1("www.google.com", 443, true,
+                             PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info1(
       new DiskCacheBasedQuicServerInfo(server_key1, cache.http_cache()));
   quic_server_info1->Start();
@@ -167,7 +168,8 @@ TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // Persist data for port 80.
-  QuicSessionKey server_key2("www.google.com", 80, false, kPrivacyModeDisabled);
+  QuicSessionKey server_key2("www.google.com", 80, false,
+                             PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info2(
       new DiskCacheBasedQuicServerInfo(server_key2, cache.http_cache()));
   quic_server_info2->Start();
@@ -230,7 +232,7 @@ TEST(DiskCacheBasedQuicServerInfo, IsReadyToPersist) {
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
-  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_key, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());

net/http/http_network_transaction.cc

@@ -196,7 +196,7 @@ int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
   // Channel ID is enabled unless --disable-tls-channel-id flag is set,
   // or if privacy mode is enabled.
   bool channel_id_enabled = server_ssl_config_.channel_id_enabled &&
-      (request_->privacy_mode == kPrivacyModeDisabled);
+      (request_->privacy_mode == PRIVACY_MODE_DISABLED);
   server_ssl_config_.channel_id_enabled = channel_id_enabled;
 
   next_state_ = STATE_NOTIFY_BEFORE_CREATE_STREAM;

net/http/http_network_transaction_unittest.cc

@@ -9218,7 +9218,7 @@ TEST_P(HttpNetworkTransactionTest,
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.google.com", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                     kPrivacyModeDisabled);
+                     PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
       CreateSecureSpdySession(session, key, BoundNetLog());
 
@@ -10377,7 +10377,7 @@ TEST_P(HttpNetworkTransactionTest, PreconnectWithExistingSpdySession) {
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.google.com", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                     kPrivacyModeDisabled);
+                     PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
       CreateInsecureSpdySession(session, key, BoundNetLog());
 
@@ -11735,7 +11735,7 @@ TEST_P(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
 
   HostPortPair host_port_pair_a("www.a.com", 443);
   SpdySessionKey spdy_session_key_a(
-      host_port_pair_a, ProxyServer::Direct(), kPrivacyModeDisabled);
+      host_port_pair_a, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
 
@@ -11767,7 +11767,7 @@ TEST_P(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
 
   HostPortPair host_port_pair_b("www.b.com", 443);
   SpdySessionKey spdy_session_key_b(
-      host_port_pair_b, ProxyServer::Direct(), kPrivacyModeDisabled);
+      host_port_pair_b, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_b));
   HttpRequestInfo request2;
@@ -11795,7 +11795,7 @@ TEST_P(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
 
   HostPortPair host_port_pair_a1("www.a.com", 80);
   SpdySessionKey spdy_session_key_a1(
-      host_port_pair_a1, ProxyServer::Direct(), kPrivacyModeDisabled);
+      host_port_pair_a1, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a1));
   HttpRequestInfo request3;

net/http/http_proxy_client_socket_pool.cc

@@ -206,7 +206,7 @@ int HttpProxyConnectJob::DoSSLConnect() {
   if (params_->tunnel()) {
     SpdySessionKey key(params_->destination().host_port_pair(),
                        ProxyServer::Direct(),
-                       kPrivacyModeDisabled);
+                       PRIVACY_MODE_DISABLED);
     if (params_->spdy_session_pool()->FindAvailableSession(key, net_log())) {
       using_spdy_ = true;
       next_state_ = STATE_SPDY_PROXY_CREATE_STREAM;
@@ -302,7 +302,7 @@ int HttpProxyConnectJob::DoSpdyProxyCreateStream() {
   DCHECK(params_->tunnel());
   SpdySessionKey key(params_->destination().host_port_pair(),
                      ProxyServer::Direct(),
-                     kPrivacyModeDisabled);
+                     PRIVACY_MODE_DISABLED);
   SpdySessionPool* spdy_pool = params_->spdy_session_pool();
   base::WeakPtr<SpdySession> spdy_session =
       spdy_pool->FindAvailableSession(key, net_log());

net/http/http_proxy_client_socket_pool_unittest.cc

@@ -135,7 +135,7 @@ class HttpProxyClientSocketPoolTest
         NULL,
         HostPortPair(kHttpsProxyHost, 443),
         SSLConfig(),
-        kPrivacyModeDisabled,
+        PRIVACY_MODE_DISABLED,
         0,
         false,
         false);

net/http/http_request_info.cc

@@ -10,7 +10,7 @@ HttpRequestInfo::HttpRequestInfo()
     : upload_data_stream(NULL),
       load_flags(0),
       motivation(NORMAL_MOTIVATION),
-      privacy_mode(kPrivacyModeDisabled) {
+      privacy_mode(PRIVACY_MODE_DISABLED) {
 }
 
 HttpRequestInfo::~HttpRequestInfo() {}

net/http/http_stream_factory_impl_job.cc

@@ -1097,7 +1097,7 @@ int HttpStreamFactoryImpl::Job::DoCreateStream() {
     // We never use privacy mode for connection to proxy server.
     spdy_session_key = SpdySessionKey(proxy_server.host_port_pair(),
                                       ProxyServer::Direct(),
-                                      kPrivacyModeDisabled);
+                                      PRIVACY_MODE_DISABLED);
     direct = false;
   }
 
@@ -1283,7 +1283,7 @@ void HttpStreamFactoryImpl::Job::InitSSLConfig(
     ssl_config->verify_ev_cert = true;
 
   // Disable Channel ID if privacy mode is enabled.
-  if (request_info_.privacy_mode == kPrivacyModeEnabled)
+  if (request_info_.privacy_mode == PRIVACY_MODE_ENABLED)
     ssl_config->channel_id_enabled = false;
 }
 

net/http/http_stream_factory_impl_unittest.cc

@@ -550,7 +550,7 @@ TEST_P(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
     // Put a SpdySession in the pool.
     HostPortPair host_port_pair("www.google.com", 443);
     SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                       kPrivacyModeDisabled);
+                       PRIVACY_MODE_DISABLED);
     ignore_result(CreateFakeSpdySession(session->spdy_session_pool(), key));
 
     CapturePreconnectsTransportSocketPool* transport_conn_pool =
@@ -661,13 +661,13 @@ TEST_P(HttpStreamFactoryTest, PrivacyModeDisablesChannelId) {
   // Set an existing SpdySession in the pool.
   HostPortPair host_port_pair("www.google.com", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                     kPrivacyModeEnabled);
+                     PRIVACY_MODE_ENABLED);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
-  request_info.privacy_mode = kPrivacyModeDisabled;
+  request_info.privacy_mode = PRIVACY_MODE_DISABLED;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
@@ -720,7 +720,7 @@ TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
-  request_info.privacy_mode = kPrivacyModeDisabled;
+  request_info.privacy_mode = PRIVACY_MODE_DISABLED;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
@@ -741,7 +741,7 @@ TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
 
   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
 
-  request_info.privacy_mode = kPrivacyModeEnabled;
+  request_info.privacy_mode = PRIVACY_MODE_ENABLED;
   scoped_ptr<HttpStreamRequest> request3(
       session->http_stream_factory()->RequestStream(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,

net/quic/crypto/quic_crypto_client_config_test.cc

@@ -57,7 +57,7 @@ TEST(QuicCryptoClientConfigTest, InchoateChlo) {
   QuicCryptoClientConfig config;
   QuicCryptoNegotiatedParameters params;
   CryptoHandshakeMessage msg;
-  QuicSessionKey server_key("www.google.com", 80, false, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
   config.FillInchoateClientHello(server_key, QuicVersionMax(), &state,
                                  &params, &msg);
 
@@ -75,7 +75,7 @@ TEST(QuicCryptoClientConfigTest, FillClientHello) {
   string error_details;
   MockRandom rand;
   CryptoHandshakeMessage chlo;
-  QuicSessionKey server_key("www.google.com", 80, false, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
   config.FillClientHello(server_key,
                          kConnectionId,
                          QuicVersionMax(),
@@ -102,7 +102,7 @@ TEST(QuicCryptoClientConfigTest, InchoateChloSecure) {
   QuicCryptoClientConfig config;
   QuicCryptoNegotiatedParameters params;
   CryptoHandshakeMessage msg;
-  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   config.FillInchoateClientHello(server_key, QuicVersionMax(), &state,
                                  &params, &msg);
 
@@ -117,7 +117,7 @@ TEST(QuicCryptoClientConfigTest, InchoateChloSecureNoEcdsa) {
   config.DisableEcdsa();
   QuicCryptoNegotiatedParameters params;
   CryptoHandshakeMessage msg;
-  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
+  QuicSessionKey server_key("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   config.FillInchoateClientHello(server_key, QuicVersionMax(), &state,
                                  &params, &msg);
 
@@ -154,14 +154,14 @@ TEST(QuicCryptoClientConfigTest, ProcessServerDowngradeAttack) {
 TEST(QuicCryptoClientConfigTest, InitializeFrom) {
   QuicCryptoClientConfig config;
   QuicSessionKey canonical_key1("www.google.com", 80, false,
-                                kPrivacyModeDisabled);
+                                PRIVACY_MODE_DISABLED);
   QuicCryptoClientConfig::CachedState* state =
       config.LookupOrCreate(canonical_key1);
   // TODO(rch): Populate other fields of |state|.
   state->set_source_address_token("TOKEN");
   state->SetProofValid();
 
-  QuicSessionKey other_key("mail.google.com", 80, false, kPrivacyModeDisabled);
+  QuicSessionKey other_key("mail.google.com", 80, false, PRIVACY_MODE_DISABLED);
   config.InitializeFrom(other_key, canonical_key1, &config);
   QuicCryptoClientConfig::CachedState* other = config.LookupOrCreate(other_key);
 

net/quic/quic_client_session_test.cc

@@ -71,7 +71,7 @@ class QuicClientSessionTest : public ::testing::TestWithParam<QuicVersion> {
         session_(connection_, GetSocket().Pass(), writer_.Pass(), NULL, NULL,
                  make_scoped_ptr((QuicServerInfo*)NULL),
                  QuicSessionKey(kServerHostname, kServerPort, false,
-                                kPrivacyModeDisabled),
+                                PRIVACY_MODE_DISABLED),
                  DefaultQuicConfig(), &crypto_config_, &net_log_) {
     session_.config()->SetDefaults();
     crypto_config_.SetDefaults();

net/quic/quic_crypto_client_stream_test.cc

@@ -29,7 +29,7 @@ class QuicCryptoClientStreamTest : public ::testing::Test {
   QuicCryptoClientStreamTest()
       : connection_(new PacketSavingConnection(false)),
         session_(new TestClientSession(connection_, DefaultQuicConfig())),
-        server_key_(kServerHostname, kServerPort, false, kPrivacyModeDisabled),
+        server_key_(kServerHostname, kServerPort, false, PRIVACY_MODE_DISABLED),
         stream_(new QuicCryptoClientStream(
             server_key_, session_.get(), NULL, &crypto_config_)) {
     session_->SetCryptoStream(stream_.get());
@@ -107,7 +107,7 @@ TEST_F(QuicCryptoClientStreamTest, NegotiatedParameters) {
 }
 
 TEST_F(QuicCryptoClientStreamTest, InvalidHostname) {
-  QuicSessionKey server_key("invalid", 80, false, kPrivacyModeDisabled);
+  QuicSessionKey server_key("invalid", 80, false, PRIVACY_MODE_DISABLED);
   stream_.reset(new QuicCryptoClientStream(server_key, session_.get(), NULL,
                                            &crypto_config_));
   session_->SetCryptoStream(stream_.get());

net/quic/quic_crypto_server_stream_test.cc

@@ -146,7 +146,7 @@ TEST_P(QuicCryptoServerStreamTest, ZeroRTT) {
   client_crypto_config.SetDefaults();
 
   QuicSessionKey server_key(kServerHostname, kServerPort, false,
-                            kPrivacyModeDisabled);
+                            PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicCryptoClientStream> client(new QuicCryptoClientStream(
       server_key, client_session.get(), NULL, &client_crypto_config));
   client_session->SetCryptoStream(client.get());

net/quic/quic_http_stream_test.cc

@@ -209,7 +209,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
                               &crypto_client_stream_factory_,
                               make_scoped_ptr((QuicServerInfo*)NULL),
                               QuicSessionKey(kServerHostname, kServerPort,
-                                             false, kPrivacyModeDisabled),
+                                             false, PRIVACY_MODE_DISABLED),
                               DefaultQuicConfig(), &crypto_config_, NULL));
     session_->GetCryptoStream()->CryptoConnect();
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());

net/quic/quic_session_key.cc

@@ -45,7 +45,7 @@ bool QuicSessionKey::operator==(const QuicSessionKey& other) const {
 
 string QuicSessionKey::ToString() const {
   return (is_https_ ? "https://" : "http://") + host_port_pair_.ToString() +
-      (privacy_mode_ == kPrivacyModeEnabled ? "/private" : "");
+      (privacy_mode_ == PRIVACY_MODE_ENABLED ? "/private" : "");
 }
 
 }  // namespace net

net/quic/quic_session_key_test.cc

@@ -16,22 +16,22 @@ TEST(QuicSessionKeyTest, ToString) {
   HostPortPair google_host_port_pair("google.com", 10);
 
   QuicSessionKey google_http_key(google_host_port_pair, false,
-                                 kPrivacyModeDisabled);
+                                 PRIVACY_MODE_DISABLED);
   string google_http_key_str = google_http_key.ToString();
   EXPECT_EQ("http://google.com:10", google_http_key_str);
 
   QuicSessionKey google_https_key(google_host_port_pair, true,
-                                 kPrivacyModeDisabled);
+                                 PRIVACY_MODE_DISABLED);
   string google_https_key_str = google_https_key.ToString();
   EXPECT_EQ("https://google.com:10", google_https_key_str);
 
   QuicSessionKey private_http_key(google_host_port_pair, false,
-                                  kPrivacyModeEnabled);
+                                  PRIVACY_MODE_ENABLED);
   string private_http_key_str = private_http_key.ToString();
   EXPECT_EQ("http://google.com:10/private", private_http_key_str);
 
   QuicSessionKey private_https_key(google_host_port_pair, true,
-                                   kPrivacyModeEnabled);
+                                   PRIVACY_MODE_ENABLED);
   string private_https_key_str = private_https_key.ToString();
   EXPECT_EQ("https://google.com:10/private", private_https_key_str);
 }