Revert of Rename PrivateMode enum values: (https://codereview.chromiu…

…m.org/215023002/)

Reason for revert:
Broke build.

http://build.chromium.org/p/chromium.linux/builders/Linux%20Builder%20%28dbg%29/builds/71042/steps/compile/logs/stdio#error1

Original issue's description:
> 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

TBR=mef@chromium.org,zea@chromium.org
NOTREECHECKS=true
NOTRY=true

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260296 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::PRIVACY_MODE_ENABLED;
+    request_info.privacy_mode = net::kPrivacyModeEnabled;
 
   // 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

@@ -331,7 +331,7 @@ void ConnectionFactoryImpl::OnProxyResolveDone(int status) {
       proxy_info_,
       ssl_config,
       ssl_config,
-      net::PRIVACY_MODE_DISABLED,
+      net::kPrivacyModeDisabled,
       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::PRIVACY_MODE_DISABLED, bound_net_log_, transport_.get(),
+      ssl_config_, net::kPrivacyModeDisabled, 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,10 +10,11 @@ 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 {
-  PRIVACY_MODE_DISABLED = 0,
-  PRIVACY_MODE_ENABLED = 1,
+  kPrivacyModeDisabled = 0,
+  kPrivacyModeEnabled = 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,
-                            PRIVACY_MODE_DISABLED);
+                            kPrivacyModeDisabled);
   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, PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_key, cache.http_cache()));
   quic_server_info->Start();
@@ -143,8 +143,7 @@ TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
   TestCompletionCallback callback;
 
   // Persist data for port 443.
-  QuicSessionKey server_key1("www.google.com", 443, true,
-                             PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key1("www.google.com", 443, true, kPrivacyModeDisabled);
   scoped_ptr<QuicServerInfo> quic_server_info1(
       new DiskCacheBasedQuicServerInfo(server_key1, cache.http_cache()));
   quic_server_info1->Start();
@@ -168,8 +167,7 @@ TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // Persist data for port 80.
-  QuicSessionKey server_key2("www.google.com", 80, false,
-                             PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key2("www.google.com", 80, false, kPrivacyModeDisabled);
   scoped_ptr<QuicServerInfo> quic_server_info2(
       new DiskCacheBasedQuicServerInfo(server_key2, cache.http_cache()));
   quic_server_info2->Start();
@@ -232,7 +230,7 @@ TEST(DiskCacheBasedQuicServerInfo, IsReadyToPersist) {
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
-  QuicSessionKey server_key("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key("www.google.com", 443, true, kPrivacyModeDisabled);
   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 == PRIVACY_MODE_DISABLED);
+      (request_->privacy_mode == kPrivacyModeDisabled);
   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(),
-                     PRIVACY_MODE_DISABLED);
+                     kPrivacyModeDisabled);
   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(),
-                     PRIVACY_MODE_DISABLED);
+                     kPrivacyModeDisabled);
   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(), PRIVACY_MODE_DISABLED);
+      host_port_pair_a, ProxyServer::Direct(), kPrivacyModeDisabled);
   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(), PRIVACY_MODE_DISABLED);
+      host_port_pair_b, ProxyServer::Direct(), kPrivacyModeDisabled);
   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(), PRIVACY_MODE_DISABLED);
+      host_port_pair_a1, ProxyServer::Direct(), kPrivacyModeDisabled);
   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(),
-                       PRIVACY_MODE_DISABLED);
+                       kPrivacyModeDisabled);
     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(),
-                     PRIVACY_MODE_DISABLED);
+                     kPrivacyModeDisabled);
   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(),
-        PRIVACY_MODE_DISABLED,
+        kPrivacyModeDisabled,
         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(PRIVACY_MODE_DISABLED) {
+      privacy_mode(kPrivacyModeDisabled) {
 }
 
 HttpRequestInfo::~HttpRequestInfo() {}

net/http/http_stream_factory_impl_job.cc

@@ -1092,7 +1092,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(),
-                                      PRIVACY_MODE_DISABLED);
+                                      kPrivacyModeDisabled);
     direct = false;
   }
 
@@ -1278,7 +1278,7 @@ void HttpStreamFactoryImpl::Job::InitSSLConfig(
     ssl_config->verify_ev_cert = true;
 
   // Disable Channel ID if privacy mode is enabled.
-  if (request_info_.privacy_mode == PRIVACY_MODE_ENABLED)
+  if (request_info_.privacy_mode == kPrivacyModeEnabled)
     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(),
-                       PRIVACY_MODE_DISABLED);
+                       kPrivacyModeDisabled);
     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(),
-                     PRIVACY_MODE_ENABLED);
+                     kPrivacyModeEnabled);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
-  request_info.privacy_mode = PRIVACY_MODE_DISABLED;
+  request_info.privacy_mode = kPrivacyModeDisabled;
 
   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 = PRIVACY_MODE_DISABLED;
+  request_info.privacy_mode = kPrivacyModeDisabled;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
@@ -741,7 +741,7 @@ TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
 
   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
 
-  request_info.privacy_mode = PRIVACY_MODE_ENABLED;
+  request_info.privacy_mode = kPrivacyModeEnabled;
   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

@@ -56,7 +56,7 @@ TEST(QuicCryptoClientConfigTest, InchoateChlo) {
   QuicCryptoClientConfig config;
   QuicCryptoNegotiatedParameters params;
   CryptoHandshakeMessage msg;
-  QuicSessionKey server_key("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key("www.google.com", 80, false, kPrivacyModeDisabled);
   config.FillInchoateClientHello(server_key, QuicVersionMax(), &state,
                                  &params, &msg);
 
@@ -131,14 +131,14 @@ TEST(QuicCryptoClientConfigTest, ProcessServerDowngradeAttack) {
 TEST(QuicCryptoClientConfigTest, InitializeFrom) {
   QuicCryptoClientConfig config;
   QuicSessionKey canonical_key1("www.google.com", 80, false,
-                                PRIVACY_MODE_DISABLED);
+                                kPrivacyModeDisabled);
   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, PRIVACY_MODE_DISABLED);
+  QuicSessionKey other_key("mail.google.com", 80, false, kPrivacyModeDisabled);
   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,
-                                PRIVACY_MODE_DISABLED),
+                                kPrivacyModeDisabled),
                  DefaultQuicConfig(), &crypto_config_, &net_log_) {
     session_.config()->SetDefaults();
     crypto_config_.SetDefaults();

net/quic/quic_crypto_client_stream_test.cc

@@ -28,7 +28,7 @@ class QuicCryptoClientStreamTest : public ::testing::Test {
   QuicCryptoClientStreamTest()
       : connection_(new PacketSavingConnection(false)),
         session_(new TestClientSession(connection_, DefaultQuicConfig())),
-        server_key_(kServerHostname, kServerPort, false, PRIVACY_MODE_DISABLED),
+        server_key_(kServerHostname, kServerPort, false, kPrivacyModeDisabled),
         stream_(new QuicCryptoClientStream(
             server_key_, session_.get(), NULL, &crypto_config_)) {
     session_->SetCryptoStream(stream_.get());
@@ -106,7 +106,7 @@ TEST_F(QuicCryptoClientStreamTest, NegotiatedParameters) {
 }
 
 TEST_F(QuicCryptoClientStreamTest, InvalidHostname) {
-  QuicSessionKey server_key("invalid", 80, false, PRIVACY_MODE_DISABLED);
+  QuicSessionKey server_key("invalid", 80, false, kPrivacyModeDisabled);
   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,
-                            PRIVACY_MODE_DISABLED);
+                            kPrivacyModeDisabled);
   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, PRIVACY_MODE_DISABLED),
+                                             false, kPrivacyModeDisabled),
                               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_ == PRIVACY_MODE_ENABLED ? "/private" : "");
+      (privacy_mode_ == kPrivacyModeEnabled ? "/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,
-                                 PRIVACY_MODE_DISABLED);
+                                 kPrivacyModeDisabled);
   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,
-                                 PRIVACY_MODE_DISABLED);
+                                 kPrivacyModeDisabled);
   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,
-                                  PRIVACY_MODE_ENABLED);
+                                  kPrivacyModeEnabled);
   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,
-                                   PRIVACY_MODE_ENABLED);
+                                   kPrivacyModeEnabled);
   string private_https_key_str = private_https_key.ToString();
   EXPECT_EQ("https://google.com:10/private", private_https_key_str);
 }

net/quic/quic_stream_factory_test.cc

@@ -48,15 +48,15 @@ class QuicStreamFactoryPeer {
   static bool HasActiveSession(QuicStreamFactory* factory,
                                const HostPortPair& host_port_pair,
                                bool is_https) {
-    QuicSessionKey server_key(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
+    QuicSessionKey server_key(host_port_pair, is_https, kPrivacyModeDisabled);
     return factory->HasActiveSession(server_key);
   }
 
   static QuicClientSession* GetActiveSession(
       QuicStreamFactory* factory,
       const HostPortPair& host_port_pair,
       bool is_https) {
-    QuicSessionKey server_key(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
+    QuicSessionKey server_key(host_port_pair, is_https, kPrivacyModeDisabled);
     DCHECK(factory->HasActiveSession(server_key));
     return factory->active_sessions_[server_key];
   }
@@ -66,7 +66,7 @@ class QuicStreamFactoryPeer {
       const HostPortPair& host_port_pair,
       bool is_https,
       const BoundNetLog& net_log) {
-    QuicSessionKey server_key(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
+    QuicSessionKey server_key(host_port_pair, is_https, kPrivacyModeDisabled);
     return factory->CreateIfSessionExists(server_key, net_log);
   }
 
@@ -97,7 +97,7 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
                  SupportedVersions(GetParam()), true, true),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
         is_https_(false),
-        privacy_mode_(PRIVACY_MODE_DISABLED) {
+        privacy_mode_(kPrivacyModeDisabled) {
     factory_.set_require_confirmation(false);
   }
 

net/quic/test_tools/crypto_test_utils.cc

@@ -180,7 +180,7 @@ int CryptoTestUtils::HandshakeWithFakeClient(
     crypto_config.SetChannelIDSigner(ChannelIDSignerForTesting());
   }
   QuicSessionKey server_key(kServerHostname, kServerPort, false,
-                            PRIVACY_MODE_DISABLED);
+                            kPrivacyModeDisabled);
   QuicCryptoClientStream client(server_key, &client_session, NULL,
                                 &crypto_config);
   client_session.SetCryptoStream(&client);