[cast_channel] Create KeepAliveDelegate in CastSocket instead of in CastChannelOpenFunction

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/cast_channel/cast_auth_util.h"
 #include "components/cast_channel/cast_framer.h"
 #include "components/cast_channel/cast_message_util.h"
 #include "components/cast_channel/cast_transport.h"
+#include "components/cast_channel/keep_alive_delegate.h"
 #include "components/cast_channel/logger.h"
 #include "components/cast_channel/proto/cast_channel.pb.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cert/x509_certificate.h"
@@ skipping 41 matching lines @@
     verify_result->Reset();
     verify_result->verified_cert = params.certificate();
     return net::OK;
   }
 };
 
 }  // namespace
 
 CastSocketImpl::CastSocketImpl(const net::IPEndPoint& ip_endpoint,
                                net::NetLog* net_log,
-                               const base::TimeDelta& timeout,
-                               bool keep_alive,
+                               base::TimeDelta timeout,
+                               base::TimeDelta liveness_timeout,
+                               base::TimeDelta ping_interval,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities)
     : CastSocketImpl(ip_endpoint,
                      net_log,
                      timeout,
-                     keep_alive,
+                     liveness_timeout,
+                     ping_interval,
                      logger,
                      device_capabilities,
                      AuthContext::Create()) {}
 
 CastSocketImpl::CastSocketImpl(const net::IPEndPoint& ip_endpoint,
                                net::NetLog* net_log,
-                               const base::TimeDelta& timeout,
-                               bool keep_alive,
+                               base::TimeDelta timeout,
+                               base::TimeDelta liveness_timeout,
+                               base::TimeDelta ping_interval,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities,
                                const AuthContext& auth_context)
     : channel_id_(0),
       ip_endpoint_(ip_endpoint),
       net_log_(net_log),
-      keep_alive_(keep_alive),
+      liveness_timeout_(liveness_timeout),
+      ping_interval_(ping_interval),
       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),
       error_state_(ChannelError::NONE),
       ready_state_(ReadyState::NONE),
@@ skipping 26 matching lines @@
 
 int CastSocketImpl::id() const {
   return channel_id_;
 }
 
 void CastSocketImpl::set_id(int id) {
   channel_id_ = id;
 }
 
 bool CastSocketImpl::keep_alive() const {
-  return keep_alive_;
+  return liveness_timeout_ > base::TimeDelta();
 }
 
 bool CastSocketImpl::audio_only() const {
   return audio_only_;
 }
 
 std::unique_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
   net::AddressList addresses(ip_endpoint_);
   return std::unique_ptr<net::TCPClientSocket>(
       new net::TCPClientSocket(addresses, nullptr, net_log_, net_log_source_));
@@ skipping 352 matching lines @@
 void CastSocketImpl::DoConnectCallback() {
   VLOG(1) << "DoConnectCallback (error_state = "
           << ::cast_channel::ChannelErrorToString(error_state_) << ")";
   if (connect_callback_.is_null()) {
     DLOG(FATAL) << "Connection callback invoked multiple times.";
     return;
   }
 
   if (error_state_ == ChannelError::NONE) {
     SetReadyState(ReadyState::OPEN);
+    if (keep_alive()) {
+      auto* keep_alive_delegate =
+          new KeepAliveDelegate(this, logger_, std::move(delegate_),
+                                ping_interval_, liveness_timeout_);
+      delegate_.reset(keep_alive_delegate);
+    }
     transport_->SetReadDelegate(std::move(delegate_));
   } else {
     CloseInternal();
   }
 
   base::ResetAndReturn(&connect_callback_).Run(error_state_);
 }
 
 void CastSocketImpl::Close(const net::CompletionCallback& callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@@ skipping 45 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