envoyproxy · rlazarus · May 26, 2017 · May 26, 2017
diff --git a/source/common/common/thread.cc b/source/common/common/thread.cc
@@ -10,7 +10,7 @@
 namespace Envoy {
 namespace Thread {
 
-Thread::Thread(std::function<void()> thread_routine) : thread_routine_(thread_routine) {
+Thread::Thread(std::function<void()> thread_routine) : thread_routine_(std::move(thread_routine)) {
   int rc = pthread_create(&thread_id_, nullptr, [](void* arg) -> void* {
     static_cast<Thread*>(arg)->thread_routine_();
     return nullptr;

diff --git a/source/common/event/file_event_impl.cc b/source/common/event/file_event_impl.cc
@@ -12,7 +12,7 @@ namespace Event {
 
 FileEventImpl::FileEventImpl(DispatcherImpl& dispatcher, int fd, FileReadyCb cb,
                              FileTriggerType trigger, uint32_t events)
-    : cb_(cb), base_(&dispatcher.base()), fd_(fd), trigger_(trigger) {
+    : cb_(std::move(cb)), base_(&dispatcher.base()), fd_(fd), trigger_(trigger) {
   assignEvents(events);
   event_add(&raw_event_, nullptr);
 }

diff --git a/source/common/event/signal_impl.cc b/source/common/event/signal_impl.cc
@@ -8,7 +8,7 @@ namespace Envoy {
 namespace Event {
 
 SignalEventImpl::SignalEventImpl(DispatcherImpl& dispatcher, int signal_num, SignalCb cb)
-    : cb_(cb) {
+    : cb_(std::move(cb)) {
   evsignal_assign(&raw_event_, &dispatcher.base(),
                   signal_num, [](evutil_socket_t, short, void* arg) -> void {
                     static_cast<SignalEventImpl*>(arg)->cb_();

diff --git a/source/common/event/timer_impl.cc b/source/common/event/timer_impl.cc
@@ -10,7 +10,7 @@
 namespace Envoy {
 namespace Event {
 
-TimerImpl::TimerImpl(DispatcherImpl& dispatcher, TimerCb cb) : cb_(cb) {
+TimerImpl::TimerImpl(DispatcherImpl& dispatcher, TimerCb cb) : cb_(std::move(cb)) {
   ASSERT(cb_);
   evtimer_assign(&raw_event_, &dispatcher.base(), [](evutil_socket_t, short, void* arg) -> void {
     static_cast<TimerImpl*>(arg)->cb_();

diff --git a/source/common/filter/auth/client_ssl.h b/source/common/filter/auth/client_ssl.h
@@ -107,7 +107,7 @@ class Config : public Http::RestApiFetcher {
  */
 class Instance : public Network::ReadFilter, public Network::ConnectionCallbacks {
 public:
-  Instance(ConfigSharedPtr config) : config_(config) {}
+  Instance(ConfigSharedPtr config) : config_(std::move(config)) {}
 
   // Network::ReadFilter
   Network::FilterStatus onData(Buffer::Instance& data) override;

diff --git a/source/common/filter/ratelimit.h b/source/common/filter/ratelimit.h
@@ -70,7 +70,7 @@ class Instance : public Network::ReadFilter,
                  public RequestCallbacks {
 public:
   Instance(ConfigSharedPtr config, ClientPtr&& client)
-      : config_(config), client_(std::move(client)) {}
+      : config_(std::move(config)), client_(std::move(client)) {}
 
   // Network::ReadFilter
   Network::FilterStatus onData(Buffer::Instance& data) override;

diff --git a/source/common/filter/tcp_proxy.cc b/source/common/filter/tcp_proxy.cc
@@ -89,7 +89,7 @@ const std::string& TcpProxyConfig::getRouteFromEntries(Network::Connection& conn
 }
 
 TcpProxy::TcpProxy(TcpProxyConfigSharedPtr config, Upstream::ClusterManager& cluster_manager)
-    : config_(config), cluster_manager_(cluster_manager), downstream_callbacks_(*this),
+    : config_(std::move(config)), cluster_manager_(cluster_manager), downstream_callbacks_(*this),
       upstream_callbacks_(new UpstreamCallbacks(*this)) {}
 
 TcpProxy::~TcpProxy() {

diff --git a/source/common/http/codec_client.cc b/source/common/http/codec_client.cc
@@ -13,7 +13,7 @@ namespace Http {
 
 CodecClient::CodecClient(Type type, Network::ClientConnectionPtr&& connection,
                          Upstream::HostDescriptionConstSharedPtr host)
-    : type_(type), connection_(std::move(connection)), host_(host) {
+    : type_(type), connection_(std::move(connection)), host_(std::move(host)) {
 
   connection_->addConnectionCallbacks(*this);
   connection_->addReadFilter(Network::ReadFilterSharedPtr{new CodecReadFilter(*this)});

diff --git a/source/common/http/conn_manager_impl.h b/source/common/http/conn_manager_impl.h
@@ -300,7 +300,7 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
                                      LinkedObject<ActiveStreamDecoderFilter> {
     ActiveStreamDecoderFilter(ActiveStream& parent, StreamDecoderFilterSharedPtr filter,
                               bool dual_filter)
-        : ActiveStreamFilterBase(parent, dual_filter), handle_(filter) {}
+        : ActiveStreamFilterBase(parent, dual_filter), handle_(std::move(filter)) {}
 
     // ActiveStreamFilterBase
     Buffer::InstancePtr& bufferedData() override { return parent_.buffered_request_data_; }
@@ -337,7 +337,7 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
                                      LinkedObject<ActiveStreamEncoderFilter> {
     ActiveStreamEncoderFilter(ActiveStream& parent, StreamEncoderFilterSharedPtr filter,
                               bool dual_filter)
-        : ActiveStreamFilterBase(parent, dual_filter), handle_(filter) {}
+        : ActiveStreamFilterBase(parent, dual_filter), handle_(std::move(filter)) {}
 
     // ActiveStreamFilterBase
     Buffer::InstancePtr& bufferedData() override { return parent_.buffered_response_data_; }

diff --git a/source/common/http/filter/buffer_filter.cc b/source/common/http/filter/buffer_filter.cc
@@ -15,7 +15,7 @@
 namespace Envoy {
 namespace Http {
 
-BufferFilter::BufferFilter(BufferFilterConfigConstSharedPtr config) : config_(config) {}
+BufferFilter::BufferFilter(BufferFilterConfigConstSharedPtr config) : config_(std::move(config)) {}
 
 BufferFilter::~BufferFilter() { ASSERT(!request_timeout_); }
 

diff --git a/source/common/http/filter/fault_filter.cc b/source/common/http/filter/fault_filter.cc
@@ -60,7 +60,7 @@ FaultFilterConfig::FaultFilterConfig(const Json::Object& json_config, Runtime::L
   upstream_cluster_ = json_config.getString("upstream_cluster", EMPTY_STRING);
 }
 
-FaultFilter::FaultFilter(FaultFilterConfigSharedPtr config) : config_(config) {}
+FaultFilter::FaultFilter(FaultFilterConfigSharedPtr config) : config_(std::move(config)) {}
 
 FaultFilter::~FaultFilter() { ASSERT(!delay_timer_); }
 

diff --git a/source/common/http/filter/ratelimit.h b/source/common/http/filter/ratelimit.h
@@ -77,7 +77,7 @@ typedef std::shared_ptr<FilterConfig> FilterConfigSharedPtr;
 class Filter : public StreamDecoderFilter, public Envoy::RateLimit::RequestCallbacks {
 public:
   Filter(FilterConfigSharedPtr config, Envoy::RateLimit::ClientPtr&& client)
-      : config_(config), client_(std::move(client)) {}
+      : config_(std::move(config)), client_(std::move(client)) {}
 
   // Http::StreamFilterBase
   void onDestroy() override;

diff --git a/source/common/http/http1/conn_pool.h b/source/common/http/http1/conn_pool.h
@@ -29,7 +29,7 @@ class ConnPoolImpl : Logger::Loggable<Logger::Id::pool>, public ConnectionPool::
 public:
   ConnPoolImpl(Event::Dispatcher& dispatcher, Upstream::HostConstSharedPtr host,
                Upstream::ResourcePriority priority)
-      : dispatcher_(dispatcher), host_(host), priority_(priority) {}
+      : dispatcher_(dispatcher), host_(std::move(host)), priority_(priority) {}
 
   ~ConnPoolImpl();
 
@@ -131,7 +131,7 @@ class ConnPoolImplProd : public ConnPoolImpl {
 public:
   ConnPoolImplProd(Event::Dispatcher& dispatcher, Upstream::HostConstSharedPtr host,
                    Upstream::ResourcePriority priority)
-      : ConnPoolImpl(dispatcher, host, priority) {}
+      : ConnPoolImpl(dispatcher, std::move(host), priority) {}
 
   // ConnPoolImpl
   CodecClientPtr createCodecClient(Upstream::Host::CreateConnectionData& data) override;

diff --git a/source/common/http/http2/conn_pool.cc b/source/common/http/http2/conn_pool.cc
@@ -16,7 +16,7 @@ namespace Http2 {
 
 ConnPoolImpl::ConnPoolImpl(Event::Dispatcher& dispatcher, Upstream::HostConstSharedPtr host,
                            Upstream::ResourcePriority priority)
-    : dispatcher_(dispatcher), host_(host), priority_(priority) {}
+    : dispatcher_(dispatcher), host_(std::move(host)), priority_(priority) {}
 
 ConnPoolImpl::~ConnPoolImpl() {
   if (primary_client_) {

diff --git a/source/common/json/json_loader.cc b/source/common/json/json_loader.cc
@@ -53,13 +53,13 @@ class Field : public Object, public std::enable_shared_from_this<Field> {
     return FieldSharedPtr{new Field(value)};
   }
 
-  void append(FieldSharedPtr field_ptr) {
+  void append(const FieldSharedPtr& field_ptr) {
     checkType(Type::Array);
     value_.array_value_.push_back(field_ptr);
   }
   void insert(const std::string& key, FieldSharedPtr field_ptr) {
     checkType(Type::Object);
-    value_.object_value_[key] = field_ptr;
+    value_.object_value_[key] = std::move(field_ptr);
   }
 
   uint64_t hash() const override;
@@ -215,7 +215,7 @@ class ObjectHandler : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Obj
   ObjectSharedPtr getRoot() { return root_; }
 
 private:
-  bool handleValueEvent(FieldSharedPtr ptr);
+  bool handleValueEvent(const FieldSharedPtr& ptr);
 
   enum State {
     expectRoot,
@@ -638,7 +638,7 @@ bool ObjectHandler::RawNumber(const char*, rapidjson::SizeType, bool) {
   NOT_REACHED;
 }
 
-bool ObjectHandler::handleValueEvent(FieldSharedPtr ptr) {
+bool ObjectHandler::handleValueEvent(const FieldSharedPtr& ptr) {
   ptr->setLineNumberStart(stream_.getLineNumber());
 
   switch (state_) {

diff --git a/source/common/local_info/local_info_impl.h b/source/common/local_info/local_info_impl.h
@@ -9,9 +9,9 @@ namespace LocalInfo {
 
 class LocalInfoImpl : public LocalInfo {
 public:
-  LocalInfoImpl(Network::Address::InstanceConstSharedPtr address, const std::string zone_name,
-                const std::string cluster_name, const std::string node_name)
-      : address_(address), zone_name_(zone_name), cluster_name_(cluster_name),
+  LocalInfoImpl(Network::Address::InstanceConstSharedPtr address, const std::string& zone_name,
+                const std::string& cluster_name, const std::string& node_name)
+      : address_(std::move(address)), zone_name_(zone_name), cluster_name_(cluster_name),
         node_name_(node_name) {}
 
   Network::Address::InstanceConstSharedPtr address() const override { return address_; }

diff --git a/source/common/mongo/bson_impl.h b/source/common/mongo/bson_impl.h
@@ -48,7 +48,7 @@ class FieldImpl : public Field {
 
   explicit FieldImpl(Type type, const std::string& key, DocumentSharedPtr value)
       : type_(type), key_(key) {
-    value_.document_value_ = value;
+    value_.document_value_ = std::move(value);
   }
 
   explicit FieldImpl(const std::string& key, ObjectId&& value) : type_(Type::OBJECT_ID), key_(key) {

diff --git a/source/common/mongo/proxy.cc b/source/common/mongo/proxy.cc
@@ -38,7 +38,7 @@ void AccessLog::logMessage(const Message& message, bool full,
 ProxyFilter::ProxyFilter(const std::string& stat_prefix, Stats::Store& store,
                          Runtime::Loader& runtime, AccessLogSharedPtr access_log)
     : stat_prefix_(stat_prefix), stat_store_(store), stats_(generateStats(stat_prefix, store)),
-      runtime_(runtime), access_log_(access_log) {
+      runtime_(runtime), access_log_(std::move(access_log)) {
 
   if (!runtime_.snapshot().featureEnabled("mongo.connection_logging_enabled", 100)) {
     // If we are not logging at the connection level, just release the shared pointer so that we

diff --git a/source/common/network/connection_impl.cc b/source/common/network/connection_impl.cc
@@ -50,8 +50,9 @@ const Address::InstanceConstSharedPtr
 ConnectionImpl::ConnectionImpl(Event::DispatcherImpl& dispatcher, int fd,
                                Address::InstanceConstSharedPtr remote_address,
                                Address::InstanceConstSharedPtr local_address)
-    : filter_manager_(*this, *this), remote_address_(remote_address), local_address_(local_address),
-      dispatcher_(dispatcher), fd_(fd), id_(++next_global_id_) {
+    : filter_manager_(*this, *this), remote_address_(std::move(remote_address)),
+      local_address_(std::move(local_address)), dispatcher_(dispatcher), fd_(fd),
+      id_(++next_global_id_) {
 
   // Treat the lack of a valid fd (which in practice only happens if we run out of FDs) as an OOM
   // condition and just crash.

diff --git a/source/common/network/filter_manager_impl.h b/source/common/network/filter_manager_impl.h
@@ -47,7 +47,7 @@ class FilterManagerImpl {
 private:
   struct ActiveReadFilter : public ReadFilterCallbacks, LinkedObject<ActiveReadFilter> {
     ActiveReadFilter(FilterManagerImpl& parent, ReadFilterSharedPtr filter)
-        : parent_(parent), filter_(filter) {}
+        : parent_(parent), filter_(std::move(filter)) {}
 
     Connection& connection() override { return parent_.connection_; }
     void continueReading() override { parent_.onContinueReading(this); }

diff --git a/source/common/network/listen_socket_impl.cc b/source/common/network/listen_socket_impl.cc
@@ -31,7 +31,7 @@ void ListenSocketImpl::doBind() {
 }
 
 TcpListenSocket::TcpListenSocket(Address::InstanceConstSharedPtr address, bool bind_to_port) {
-  local_address_ = address;
+  local_address_ = std::move(address);
   fd_ = local_address_->socket(Address::SocketType::Stream);
   RELEASE_ASSERT(fd_ != -1);
 
@@ -46,7 +46,7 @@ TcpListenSocket::TcpListenSocket(Address::InstanceConstSharedPtr address, bool b
 
 TcpListenSocket::TcpListenSocket(int fd, Address::InstanceConstSharedPtr address) {
   fd_ = fd;
-  local_address_ = address;
+  local_address_ = std::move(address);
 }
 
 UdsListenSocket::UdsListenSocket(const std::string& uds_path) {

diff --git a/source/common/network/listener_impl.cc b/source/common/network/listener_impl.cc
@@ -100,7 +100,8 @@ void ListenerImpl::errorCallback(evconnlistener*, void*) {
 
 void ListenerImpl::newConnection(int fd, Address::InstanceConstSharedPtr remote_address,
                                  Address::InstanceConstSharedPtr local_address) {
-  ConnectionPtr new_connection(new ConnectionImpl(dispatcher_, fd, remote_address, local_address));
+  ConnectionPtr new_connection(
+      new ConnectionImpl(dispatcher_, fd, std::move(remote_address), std::move(local_address)));
   new_connection->setReadBufferLimit(options_.per_connection_buffer_limit_bytes_);
   cb_.onNewConnection(std::move(new_connection));
 }

diff --git a/source/common/redis/proxy_filter.cc b/source/common/redis/proxy_filter.cc
@@ -33,7 +33,7 @@ ProxyStats ProxyFilterConfig::generateStats(const std::string& prefix, Stats::Sc
 ProxyFilter::ProxyFilter(DecoderFactory& factory, EncoderPtr&& encoder,
                          CommandSplitter::Instance& splitter, ProxyFilterConfigSharedPtr config)
     : decoder_(factory.create(*this)), encoder_(std::move(encoder)), splitter_(splitter),
-      config_(config) {
+      config_(std::move(config)) {
   config_->stats().downstream_cx_total_.inc();
   config_->stats().downstream_cx_active_.inc();
 }

diff --git a/source/common/router/config_impl.h b/source/common/router/config_impl.h
@@ -284,7 +284,7 @@ class RouteEntryImplBase : public RouteEntry,
    */
   class WeightedClusterEntry : public DynanmicRouteEntry {
   public:
-    WeightedClusterEntry(const RouteEntryImplBase* parent, const std::string runtime_key,
+    WeightedClusterEntry(const RouteEntryImplBase* parent, const std::string& runtime_key,
                          Runtime::Loader& loader, const std::string& name, uint64_t weight)
         : DynanmicRouteEntry(parent, name), runtime_key_(runtime_key), loader_(loader),
           cluster_weight_(weight) {}

diff --git a/source/common/router/rds_impl.h b/source/common/router/rds_impl.h
@@ -92,7 +92,7 @@ class RdsRouteConfigProviderImpl : public RouteConfigProvider,
 
 private:
   struct ThreadLocalConfig : public ThreadLocal::ThreadLocalObject {
-    ThreadLocalConfig(ConfigConstSharedPtr initial_config) : config_(initial_config) {}
+    ThreadLocalConfig(ConfigConstSharedPtr initial_config) : config_(std::move(initial_config)) {}
 
     // ThreadLocal::ThreadLocalObject
     void shutdown() override {}

diff --git a/source/common/router/router.cc b/source/common/router/router.cc
@@ -135,7 +135,7 @@ void Filter::chargeUpstreamCode(Http::Code code,
                                 Upstream::HostDescriptionConstSharedPtr upstream_host) {
   Http::HeaderMapImpl fake_response_headers{
       {Http::Headers::get().Status, std::to_string(enumToInt(code))}};
-  chargeUpstreamCode(fake_response_headers, upstream_host);
+  chargeUpstreamCode(fake_response_headers, std::move(upstream_host));
 }
 
 Http::FilterHeadersStatus Filter::decodeHeaders(Http::HeaderMap& headers, bool end_stream) {

diff --git a/source/common/router/router.h b/source/common/router/router.h
@@ -140,7 +140,7 @@ class Filter : Logger::Loggable<Logger::Id::router>, public Http::StreamDecoderF
     void setupPerTryTimeout();
     void onPerTryTimeout();
 
-    void onUpstreamHostSelected(Upstream::HostDescriptionConstSharedPtr host) {
+    void onUpstreamHostSelected(const Upstream::HostDescriptionConstSharedPtr& host) {
       upstream_host_ = host;
       parent_.callbacks_->requestInfo().onUpstreamHostSelected(host);
     }

diff --git a/source/common/ssl/connection_impl.cc b/source/common/ssl/connection_impl.cc
@@ -19,7 +19,7 @@ ConnectionImpl::ConnectionImpl(Event::DispatcherImpl& dispatcher, int fd,
                                Network::Address::InstanceConstSharedPtr remote_address,
                                Network::Address::InstanceConstSharedPtr local_address, Context& ctx,
                                InitialState state)
-    : Network::ConnectionImpl(dispatcher, fd, remote_address, local_address),
+    : Network::ConnectionImpl(dispatcher, fd, std::move(remote_address), std::move(local_address)),
       ctx_(dynamic_cast<Ssl::ContextImpl&>(ctx)), ssl_(ctx_.newSsl()) {
   BIO* bio = BIO_new_socket(fd, 0);
   SSL_set_bio(ssl_.get(), bio, bio);

diff --git a/source/common/thread_local/thread_local_impl.cc b/source/common/thread_local/thread_local_impl.cc
@@ -59,7 +59,7 @@ void InstanceImpl::setThreadLocal(uint32_t index, ThreadLocalObjectSharedPtr obj
     thread_local_data_.data_.resize(index + 1);
   }
 
-  thread_local_data_.data_[index] = object;
+  thread_local_data_.data_[index] = std::move(object);
 }
 
 void InstanceImpl::shutdownThread() {

diff --git a/source/common/tracing/lightstep_tracer_impl.cc b/source/common/tracing/lightstep_tracer_impl.cc
@@ -101,7 +101,7 @@ void LightStepRecorder::flushSpans() {
 
 LightStepDriver::TlsLightStepTracer::TlsLightStepTracer(lightstep::Tracer tracer,
                                                         LightStepDriver& driver)
-    : tracer_(new lightstep::Tracer(tracer)), driver_(driver) {}
+    : tracer_(new lightstep::Tracer(std::move(tracer))), driver_(driver) {}
 
 LightStepDriver::LightStepDriver(const Json::Object& config,
                                  Upstream::ClusterManager& cluster_manager, Stats::Store& stats,

diff --git a/source/common/tracing/zipkin/tracer.h b/source/common/tracing/zipkin/tracer.h
@@ -55,7 +55,7 @@ class Tracer : public TracerInterface {
    */
   Tracer(const std::string& service_name, Network::Address::InstanceConstSharedPtr address,
          Runtime::RandomGenerator& random_generator)
-      : service_name_(service_name), address_(address), reporter_(nullptr),
+      : service_name_(service_name), address_(std::move(address)), reporter_(nullptr),
         random_generator_(random_generator) {}
 
   /**

diff --git a/source/common/tracing/zipkin/zipkin_core_types.h b/source/common/tracing/zipkin/zipkin_core_types.h
@@ -59,7 +59,7 @@ class Endpoint : public ZipkinBase {
    * @param address Pointer to an object representing the endpoint's network address
    */
   Endpoint(const std::string& service_name, Network::Address::InstanceConstSharedPtr address)
-      : service_name_(service_name), address_(address) {}
+      : service_name_(service_name), address_(std::move(address)) {}
 
   /**
    * @return the endpoint's address.
@@ -69,7 +69,9 @@ class Endpoint : public ZipkinBase {
   /**
    * Sets the endpoint's address
    */
-  void setAddress(Network::Address::InstanceConstSharedPtr address) { address_ = address; }
+  void setAddress(Network::Address::InstanceConstSharedPtr address) {
+    address_ = std::move(address);
+  }
 
   /**
    * @return the endpoint's service name attribute.
@@ -122,7 +124,7 @@ class Annotation : public ZipkinBase {
    * appear on ZipkinCoreConstants. The most commonly used values are "cs", "cr", "ss" and "sr".
    * @param endpoint The endpoint object representing the annotation's endpoint attribute.
    */
-  Annotation(uint64_t timestamp, const std::string value, Endpoint& endpoint)
+  Annotation(uint64_t timestamp, const std::string& value, Endpoint& endpoint)
       : timestamp_(timestamp), value_(value), endpoint_(endpoint) {}
 
   /**

diff --git a/source/common/upstream/cluster_manager_impl.cc b/source/common/upstream/cluster_manager_impl.cc
@@ -473,7 +473,8 @@ void ClusterManagerImpl::ThreadLocalClusterManagerImpl::updateClusterMembership(
 
   ASSERT(config.thread_local_clusters_.find(name) != config.thread_local_clusters_.end());
   config.thread_local_clusters_[name]->host_set_.updateHosts(
-      hosts, healthy_hosts, hosts_per_zone, healthy_hosts_per_zone, hosts_added, hosts_removed);
+      std::move(hosts), std::move(healthy_hosts), std::move(hosts_per_zone),
+      std::move(healthy_hosts_per_zone), hosts_added, hosts_removed);
 }
 
 void ClusterManagerImpl::ThreadLocalClusterManagerImpl::shutdown() {

diff --git a/source/common/upstream/health_checker_impl.cc b/source/common/upstream/health_checker_impl.cc
@@ -235,7 +235,7 @@ HttpHealthCheckerImpl::HttpHealthCheckerImpl(const Cluster& cluster, const Json:
 
 HttpHealthCheckerImpl::HttpActiveHealthCheckSession::HttpActiveHealthCheckSession(
     HttpHealthCheckerImpl& parent, HostSharedPtr host)
-    : ActiveHealthCheckSession(parent, host), parent_(parent) {}
+    : ActiveHealthCheckSession(parent, std::move(host)), parent_(parent) {}
 
 HttpHealthCheckerImpl::HttpActiveHealthCheckSession::~HttpActiveHealthCheckSession() {
   if (client_) {
@@ -462,7 +462,7 @@ RedisHealthCheckerImpl::RedisHealthCheckerImpl(const Cluster& cluster, const Jso
 
 RedisHealthCheckerImpl::RedisActiveHealthCheckSession::RedisActiveHealthCheckSession(
     RedisHealthCheckerImpl& parent, HostSharedPtr host)
-    : ActiveHealthCheckSession(parent, host), parent_(parent) {}
+    : ActiveHealthCheckSession(parent, std::move(host)), parent_(parent) {}
 
 RedisHealthCheckerImpl::RedisActiveHealthCheckSession::~RedisActiveHealthCheckSession() {
   if (current_request_) {