[cast_channel] Clean up CastSocketImpl ctor parameters

components/cast_channel/cast_socket.cc

 // 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 "components/cast_channel/cast_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 32 matching lines @@
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_info.h"
 
 // Helper for logging data with remote host IP and authentication state.
 // Assumes |ip_endpoint_| of type net::IPEndPoint and |channel_auth_| of enum
 // type ChannelAuthType are available in the current scope.
-#define CONNECTION_INFO()                                                    \
-  "[" << ip_endpoint_.ToString()                                             \
-      << ", auth=" << ::cast_channel::ChannelAuthTypeToString(channel_auth_) \
+#define CONNECTION_INFO()                                 \
+  "[" << ip_endpoint_.ToString() << ", auth=SSL_VERIFIED" \
       << "] "
 #define VLOG_WITH_CONNECTION(level) VLOG(level) << CONNECTION_INFO()
 #define LOG_WITH_CONNECTION(level) LOG(level) << CONNECTION_INFO()
 
 namespace cast_channel {
 namespace {
 
 bool IsTerminalState(ConnectionState state) {
   return state == ConnectionState::FINISHED ||
          state == ConnectionState::CONNECT_ERROR ||
@@ skipping 13 matching lines @@
              std::unique_ptr<Request>*,
              const net::NetLogWithSource&) override {
     verify_result->Reset();
     verify_result->verified_cert = params.certificate();
     return net::OK;
   }
 };
 
 }  // namespace
 
-using ChannelError = ::cast_channel::ChannelError;
-using ChannelAuthType = ::cast_channel::ChannelAuthType;
-using ReadyState = ::cast_channel::ReadyState;
-
-CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
-                               const net::IPEndPoint& ip_endpoint,
-                               ChannelAuthType channel_auth,
+CastSocketImpl::CastSocketImpl(const net::IPEndPoint& ip_endpoint,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities)
-    : CastSocketImpl(owner_extension_id,
-                     ip_endpoint,
-                     channel_auth,
+    : CastSocketImpl(ip_endpoint,
                      net_log,
                      timeout,
                      keep_alive,
                      logger,
                      device_capabilities,
                      AuthContext::Create()) {}
 
-CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
-                               const net::IPEndPoint& ip_endpoint,
-                               ChannelAuthType channel_auth,
+CastSocketImpl::CastSocketImpl(const net::IPEndPoint& ip_endpoint,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities,
                                const AuthContext& auth_context)
     : channel_id_(0),
       ip_endpoint_(ip_endpoint),
-      channel_auth_(channel_auth),
       net_log_(net_log),
       keep_alive_(keep_alive),
       logger_(logger),
       auth_context_(auth_context),
       connect_timeout_(timeout),
       connect_timeout_timer_(new base::OneShotTimer),
       is_canceled_(false),
       device_capabilities_(device_capabilities),
       audio_only_(false),
       connect_state_(ConnectionState::START_CONNECT),
@@ skipping 27 matching lines @@
 }
 
 int CastSocketImpl::id() const {
   return channel_id_;
 }
 
 void CastSocketImpl::set_id(int id) {
   channel_id_ = id;
 }
 
-ChannelAuthType CastSocketImpl::channel_auth() const {
-  return channel_auth_;
-}
-
 bool CastSocketImpl::keep_alive() const {
   return keep_alive_;
 }
 
 bool CastSocketImpl::audio_only() const {
   return audio_only_;
 }
 
 std::unique_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
   net::AddressList addresses(ip_endpoint_);
@@ skipping 241 matching lines @@
       SetConnectState(ConnectionState::FINISHED);
       SetErrorState(ChannelError::AUTHENTICATION_ERROR);
       return net::ERR_CERT_INVALID;
     }
 
     // SSL connection succeeded.
     if (!transport_.get()) {
       // Create a channel transport if one wasn't already set (e.g. by test
       // code).
       transport_.reset(new CastTransportImpl(this->socket_.get(), channel_id_,
-                                             ip_endpoint_, channel_auth_,
-                                             logger_));
+                                             ip_endpoint_, logger_));
     }
     auth_delegate_ = new AuthTransportDelegate(this);
     transport_->SetReadDelegate(base::WrapUnique(auth_delegate_));
     SetConnectState(ConnectionState::AUTH_CHALLENGE_SEND);
   } else if (result == net::ERR_CONNECTION_TIMED_OUT) {
     SetConnectState(ConnectionState::FINISHED);
     SetErrorState(ChannelError::CONNECT_TIMEOUT);
   } else {
     SetConnectState(ConnectionState::FINISHED);
     SetErrorState(ChannelError::AUTHENTICATION_ERROR);
@@ skipping 157 matching lines @@
 void CastSocketImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(1) << "SetErrorState "
                           << ::cast_channel::ChannelErrorToString(error_state);
   DCHECK_EQ(ChannelError::NONE, error_state_);
   error_state_ = error_state;
   delegate_->OnError(error_state_);
 }
 
 }  // namespace cast_channel
 #undef VLOG_WITH_CONNECTION