simplify some constructors with in-class initializers (#1038)

simplify peer_connection, torrent and session_impl's contstructors by moving simple parts to their header files

.gitignore

@@ -34,6 +34,9 @@
 *.deps
 *.cache
 *.dirstamp
+*.swp
+*.orig
+*.rej
 
 bin
 config*
@@ -41,6 +44,10 @@ Makefile
 build-aux
 test_tmp_*
 libtool
+docs/reference*
+docs/*.html
+docs/*.png
+docs/*-ref.rst
 
 .DS_Store
 .idea

include/libtorrent/aux_/session_impl.hpp

@@ -240,7 +240,7 @@ namespace libtorrent
 			bool is_posting_torrent_updates() const override { return m_posting_torrent_updates; }
 			// this is set while the session is building the
 			// torrent status update message
-			bool m_posting_torrent_updates;
+			bool m_posting_torrent_updates = false;
 #endif
 
 			void reopen_listen_sockets();
@@ -744,7 +744,7 @@ namespace libtorrent
 #ifndef TORRENT_DISABLE_POOL_ALLOCATOR
 			// this pool is used to allocate and recycle send
 			// buffers from.
-			boost::pool<> m_send_buffers;
+			boost::pool<> m_send_buffers{send_buffer_size_impl};
 #endif
 
 			io_service& m_io_service;
@@ -766,7 +766,7 @@ namespace libtorrent
 			// the client. This is the offset into m_alert_pointers where the next
 			// alert is. If this is greater than or equal to m_alert_pointers.size()
 			// it means we need to request new alerts from the main thread.
-			mutable int m_alert_pointer_pos;
+			mutable int m_alert_pointer_pos = 0;
 #endif
 
 			// handles disk io requests asynchronously
@@ -787,7 +787,7 @@ namespace libtorrent
 			bandwidth_manager m_upload_rate;
 
 			// the peer class that all peers belong to by default
-			peer_class_t m_global_class;
+			peer_class_t m_global_class = 0;
 
 			// the peer class all TCP peers belong to by default
 			// all tcp peer connections are subject to these
@@ -796,10 +796,10 @@ namespace libtorrent
 			// throttle TCP that passes over the internet
 			// bottleneck (i.e. modem) to avoid starving out
 			// uTP connections.
-			peer_class_t m_tcp_peer_class;
+			peer_class_t m_tcp_peer_class = 0;
 
 			// peer class for local peers
-			peer_class_t m_local_peer_class;
+			peer_class_t m_local_peer_class = 0;
 
 			tracker_manager m_tracker_manager;
 			torrent_map m_torrents;
@@ -865,12 +865,12 @@ namespace libtorrent
 			// in this session. queue positions are packed (i.e. there
 			// are no gaps). If there are no torrents with queue positions
 			// this is -1.
-			int m_max_queue_pos;
+			int m_max_queue_pos = -1;
 
 			// the key is an id that is used to identify the
 			// client with the tracker only. It is randomized
 			// at startup
-			int m_key;
+			int m_key = 0;
 
 			// the addresses or device names of the interfaces we are supposed to
 			// listen on. if empty, it means that we should let the os decide
@@ -904,10 +904,10 @@ namespace libtorrent
 			// when as a socks proxy is used for peers, also
 			// listen for incoming connections on a socks connection
 			boost::shared_ptr<socket_type> m_socks_listen_socket;
-			std::uint16_t m_socks_listen_port;
+			std::uint16_t m_socks_listen_port = 0;
 
 			// round-robin index into m_outgoing_interfaces
-			mutable std::uint8_t m_interface_index;
+			mutable std::uint8_t m_interface_index = 0;
 
 			void open_new_incoming_socks_connection();
 
@@ -929,30 +929,30 @@ namespace libtorrent
 			// unchoke_interval and the unchoke set is
 			// recomputed.
 			// TODO: replace this by a proper asio timer
-			int m_unchoke_time_scaler;
+			int m_unchoke_time_scaler = 0;
 
 			// this is used to decide when to recalculate which
 			// torrents to keep queued and which to activate
 			// TODO: replace this by a proper asio timer
-			int m_auto_manage_time_scaler;
+			int m_auto_manage_time_scaler = 0;
 
 			// works like unchoke_time_scaler but it
 			// is only decreased when the unchoke set
 			// is recomputed, and when it reaches zero,
 			// the optimistic unchoke is moved to another peer.
 			// TODO: replace this by a proper asio timer
-			int m_optimistic_unchoke_time_scaler;
+			int m_optimistic_unchoke_time_scaler = 0;
 
 			// works like unchoke_time_scaler. Each time
 			// it reaches 0, and all the connections are
 			// used, the worst connection will be disconnected
 			// from the torrent with the most peers
-			int m_disconnect_time_scaler;
+			int m_disconnect_time_scaler = 90;
 
 			// when this scaler reaches zero, it will
 			// scrape one of the auto managed, paused,
 			// torrents.
-			int m_auto_scrape_time_scaler;
+			int m_auto_scrape_time_scaler = 180;
 
 			// statistics gathered from all torrents.
 			stat m_stat;
@@ -964,8 +964,8 @@ namespace libtorrent
 			virtual void sent_syn(bool ipv6) override;
 			virtual void received_synack(bool ipv6) override;
 
-			int m_peak_up_rate;
+			int m_peak_up_rate = 0;
-			int m_peak_down_rate;
+			int m_peak_down_rate = 0;
 
 			void on_tick(error_code const& e);
 
@@ -1005,13 +1005,14 @@ namespace libtorrent
 
 			// when outgoing_ports is configured, this is the
 			// port we'll bind the next outgoing socket to
-			mutable int m_next_port;
+			mutable int m_next_port = 0;
 
 #ifndef TORRENT_DISABLE_DHT
 			std::unique_ptr<dht::dht_storage_interface> m_dht_storage;
 			boost::shared_ptr<dht::dht_tracker> m_dht;
 			dht_settings m_dht_settings;
-			dht::dht_storage_constructor_type m_dht_storage_constructor;
+			dht::dht_storage_constructor_type m_dht_storage_constructor
+				= dht::dht_default_storage_constructor;
 
 			// these are used when starting the DHT
 			// (and bootstrapping it), and then erased
@@ -1031,11 +1032,11 @@ namespace libtorrent
 			// compared to this number, the DHT announce interval
 			// is updated again. This especially matters for
 			// small numbers.
-			int m_dht_interval_update_torrents;
+			int m_dht_interval_update_torrents = 0;
 
 			// the number of DHT router lookups there are currently outstanding. As
 			// long as this is > 0, we'll postpone starting the DHT
-			int m_outstanding_router_lookups;
+			int m_outstanding_router_lookups = 0;
 #endif
 
 			void send_udp_packet_hostname(char const* hostname
@@ -1065,7 +1066,7 @@ namespace libtorrent
 			// the number of torrent connection boosts
 			// connections that have been made this second
 			// this is deducted from the connect speed
-			int m_boost_connections;
+			int m_boost_connections = 0;
 
 			boost::shared_ptr<natpmp> m_natpmp;
 			boost::shared_ptr<upnp> m_upnp;
@@ -1133,18 +1134,18 @@ namespace libtorrent
 			// m_torrent_lists[torrent_want_peers_downloading]
 			// (which is a list of torrent pointers with all
 			// torrents that want peers and are downloading)
-			int m_next_downloading_connect_torrent;
+			int m_next_downloading_connect_torrent = 0;
-			int m_next_finished_connect_torrent;
+			int m_next_finished_connect_torrent = 0;
 
 			// this is the number of attempts of connecting to
 			// peers we have given to downloading torrents.
 			// when this gets high enough, we try to connect
 			// a peer from a finished torrent
-			int m_download_connect_attempts;
+			int m_download_connect_attempts = 0;
 
 			// index into m_torrent_lists[torrent_want_scrape] referring
 			// to the next torrent to auto-scrape
-			int m_next_scrape_torrent;
+			int m_next_scrape_torrent = 0;
 
 #if TORRENT_USE_INVARIANT_CHECKS
 			void check_invariant() const;
@@ -1163,7 +1164,7 @@ namespace libtorrent
 			// this keeps the timers more accurate over time
 			// as a kind of "leap second" to adjust for the
 			// accumulated error
-			std::uint16_t m_tick_residual;
+			std::uint16_t m_tick_residual = 0;
 
 #ifndef TORRENT_DISABLE_LOGGING
 			virtual void session_log(char const* fmt, ...) const override TORRENT_FORMAT(2,3);
@@ -1189,29 +1190,29 @@ namespace libtorrent
 
 			// this is true whenever we have posted a deferred-disk job
 			// it means we don't need to post another one
-			bool m_deferred_submit_disk_jobs;
+			bool m_deferred_submit_disk_jobs = false;
 
 			// this is set to true when a torrent auto-manage
 			// event is triggered, and reset whenever the message
 			// is delivered and the auto-manage is executed.
 			// there should never be more than a single pending auto-manage
 			// message in-flight at any given time.
-			bool m_pending_auto_manage;
+			bool m_pending_auto_manage = false;
 
 			// this is also set to true when triggering an auto-manage
 			// of the torrents. However, if the normal auto-manage
 			// timer comes along and executes the auto-management,
 			// this is set to false, which means the triggered event
 			// no longer needs to execute the auto-management.
-			bool m_need_auto_manage;
+			bool m_need_auto_manage = false;
 
 			// set to true when the session object
 			// is being destructed and the thread
 			// should exit
-			bool m_abort;
+			bool m_abort = false;
 
 			// is true if the session is paused
-			bool m_paused;
+			bool m_paused = false;
 
 			// this is a list of peer connections who have been
 			// corked (i.e. their network socket) and needs to be

include/libtorrent/bt_peer_connection.hpp

@@ -327,7 +327,7 @@ public:
 
 private:
 
-		enum state_t
+		enum class state_t : std::uint8_t
 		{
 #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
 			read_pe_dhkey = 0,
@@ -351,7 +351,7 @@ private:
 		};
 
 		// state of on_receive. one of the enums in state_t
-		std::uint8_t m_state;
+		state_t m_state = state_t::read_protocol_identifier;
 
 		// this is set to true if the handshake from
 		// the peer indicated that it supports the
@@ -440,23 +440,23 @@ private:
 #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
 		// used to disconnect peer if sync points are not found within
 		// the maximum number of bytes
-		int m_sync_bytes_read;
+		int m_sync_bytes_read = 0;
 #endif
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
 		// the message ID for upload only message
 		// 0 if not supported
-		std::uint8_t m_upload_only_id;
+		std::uint8_t m_upload_only_id = 0;
 
 		// the message ID for holepunch messages
-		std::uint8_t m_holepunch_id;
+		std::uint8_t m_holepunch_id = 0;
 
 		// the message ID for don't-have message
-		std::uint8_t m_dont_have_id;
+		std::uint8_t m_dont_have_id = 0;
 
 		// the message ID for share mode message
 		// 0 if not supported
-		std::uint8_t m_share_mode_id;
+		std::uint8_t m_share_mode_id = 0;
 
 		std::weak_ptr<ut_pex_peer_store> m_ut_pex;
 
@@ -464,7 +464,7 @@ private:
 #endif
 
 #if TORRENT_USE_ASSERTS
-		bool m_in_constructor;
+		bool m_in_constructor = true;
 #endif
 
 	};

include/libtorrent/peer_connection.hpp

@@ -60,6 +60,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/io_service_fwd.hpp"
 #include "libtorrent/receive_buffer.hpp"
 #include "libtorrent/aux_/allocating_handler.hpp"
+#include "libtorrent/aux_/time.hpp"
 #include "libtorrent/debug.hpp"
 #include "libtorrent/span.hpp"
 
@@ -888,33 +889,33 @@ namespace libtorrent
 
 		// the time when we last got a part of a
 		// piece packet from this peer
-		time_point m_last_piece;
+		time_point m_last_piece = aux::time_now();
 
 		// the time we sent a request to
 		// this peer the last time
-		time_point m_last_request;
+		time_point m_last_request = aux::time_now();
 		// the time we received the last
 		// piece request from the peer
-		time_point m_last_incoming_request;
+		time_point m_last_incoming_request = min_time();
 
 		// the time when we unchoked this peer
-		time_point m_last_unchoke;
+		time_point m_last_unchoke = aux::time_now();
 
 		// if we're unchoked by this peer, this
 		// was the time
-		time_point m_last_unchoked;
+		time_point m_last_unchoked = aux::time_now();
 
 		// the time we last choked this peer. min_time() in
 		// case we never unchoked it
-		time_point m_last_choke;
+		time_point m_last_choke = min_time();
 
 		// timeouts
-		time_point m_last_receive;
+		time_point m_last_receive = aux::time_now();
-		time_point m_last_sent;
+		time_point m_last_sent = aux::time_now();
 
 		// the last time we filled our send buffer with payload
 		// this is used for timeouts
-		time_point m_last_sent_payload;
+		time_point m_last_sent_payload = aux::time_now();
 
 		// the time when the first entry in the request queue was requested. Used
 		// for request timeout. it doesn't necessarily represent the time when a
@@ -923,31 +924,31 @@ namespace libtorrent
 		// Once we get that response, we set it to the current time.
 		// for more information, see the blog post at:
 		// http://blog.libtorrent.org/2011/11/block-request-time-outs/
-		time_point m_requested;
+		time_point m_requested = aux::time_now();
 
 		// a timestamp when the remote download rate
 		// was last updated
-		time_point m_remote_dl_update;
+		time_point m_remote_dl_update = aux::time_now();
 
 		// the time when async_connect was called
 		// or when the incoming connection was established
-		time_point m_connect;
+		time_point m_connect = aux::time_now();
 
 		// the time when this peer sent us a not_interested message
 		// the last time.
-		time_point m_became_uninterested;
+		time_point m_became_uninterested = aux::time_now();
 
 		// the time when we sent a not_interested message to
 		// this peer the last time.
-		time_point m_became_uninteresting;
+		time_point m_became_uninteresting = aux::time_now();
 
 		// the total payload download bytes
 		// at the last unchoke round. This is used to
 		// measure the number of bytes transferred during
 		// an unchoke cycle, to unchoke peers the more bytes
 		// they sent us
-		std::int64_t m_downloaded_at_last_round;
+		std::int64_t m_downloaded_at_last_round = 0;
-		std::int64_t m_uploaded_at_last_round;
+		std::int64_t m_uploaded_at_last_round = 0;
 
 		// this is the number of bytes we had uploaded the
 		// last time this peer was unchoked. This does not
@@ -955,19 +956,19 @@ namespace libtorrent
 		// track upload across rounds, for the full duration of
 		// the peer being unchoked. Specifically, it's used
 		// for the round-robin unchoke algorithm.
-		std::int64_t m_uploaded_at_last_unchoke;
+		std::int64_t m_uploaded_at_last_unchoke = 0;
 
 		// the number of payload bytes downloaded last second tick
-		std::int32_t m_downloaded_last_second;
+		std::int32_t m_downloaded_last_second = 0;
 
 		// the number of payload bytes uploaded last second tick
-		std::int32_t m_uploaded_last_second;
+		std::int32_t m_uploaded_last_second = 0;
 
 		// the number of bytes that the other
 		// end has to send us in order to respond
 		// to all outstanding piece requests we
 		// have sent to it
-		int m_outstanding_bytes;
+		int m_outstanding_bytes = 0;
 
 		aux::handler_storage<TORRENT_READ_HANDLER_MAX_SIZE> m_read_handler_storage;
 		aux::handler_storage<TORRENT_WRITE_HANDLER_MAX_SIZE> m_write_handler_storage;
@@ -998,11 +999,11 @@ namespace libtorrent
 
 		// the time when this peer last saw a complete copy
 		// of this torrent
-		time_t m_last_seen_complete;
+		time_t m_last_seen_complete = 0;
 
 		// the block we're currently receiving. Or
 		// (-1, -1) if we're not receiving one
-		piece_block m_receiving_block;
+		piece_block m_receiving_block = piece_block::invalid;
 
 		// the local endpoint for this peer, i.e. our address
 		// and our port. If this is set for outgoing connections
@@ -1029,7 +1030,7 @@ namespace libtorrent
 
 		// the number of outstanding bytes expected
 		// to be received by extensions
-		int m_extension_outstanding_bytes;
+		int m_extension_outstanding_bytes = 0;
 
 		// the number of time critical requests
 		// queued up in the m_request_queue that
@@ -1039,18 +1040,18 @@ namespace libtorrent
 		// requests and take the previous requests
 		// into account without submitting it all
 		// immediately
-		int m_queued_time_critical;
+		int m_queued_time_critical = 0;
 
 		// the number of bytes we are currently reading
 		// from disk, that will be added to the send
 		// buffer as soon as they complete
-		int m_reading_bytes;
+		int m_reading_bytes = 0;
 
 		// options used for the piece picker. These flags will
 		// be augmented with flags controlled by other settings
 		// like sequential download etc. These are here to
 		// let plugins control flags that should always be set
-		int m_picker_options;
+		int m_picker_options = 0;
 
 		// the number of invalid piece-requests
 		// we have got from this peer. If the request
@@ -1059,30 +1060,30 @@ namespace libtorrent
 		// peer is waiting for those pieces.
 		// we can then clear its download queue
 		// by sending choke, unchoke.
-		int m_num_invalid_requests;
+		int m_num_invalid_requests = 0;
 
 		// if [0] is -1, superseeding is not active. If it is >= 0
 		// this is the piece that is available to this peer. Only
 		// these two pieces can be downloaded from us by this peer.
 		// This will remain the current piece for this peer until
 		// another peer sends us a have message for this piece
-		int m_superseed_piece[2];
+		int m_superseed_piece[2] = {-1, -1};
 
 		// pieces downloaded since last second
 		// timer timeout; used for determining
 		// approx download rate
-		int m_remote_pieces_dled;
+		int m_remote_pieces_dled = 0;
 
 		// approximate peer download rate
-		int m_remote_dl_rate;
+		int m_remote_dl_rate = 0;
 
 		// the number of bytes send to the disk-io
 		// thread that hasn't yet been completely written.
-		int m_outstanding_writing_bytes;
+		int m_outstanding_writing_bytes = 0;
 
 		// max transfer rates seen on this peer
-		int m_download_rate_peak;
+		int m_download_rate_peak = 0;
-		int m_upload_rate_peak;
+		int m_upload_rate_peak = 0;
 
 		// when using the BitTyrant choker, this is our
 		// estimated reciprocation rate. i.e. the rate
@@ -1091,12 +1092,12 @@ namespace libtorrent
 		int m_est_reciprocation_rate;
 
 		// stop sending data after this many bytes, INT_MAX = inf
-		int m_send_barrier;
+		int m_send_barrier = INT_MAX;
 
 		// the number of request we should queue up
 		// at the remote end.
 		// TODO: 2 rename this target queue size
-		std::uint16_t m_desired_queue_size;
+		std::uint16_t m_desired_queue_size = 4;
 
 		// if set to non-zero, this peer will always prefer
 		// to request entire n pieces, rather than blocks.
@@ -1104,14 +1105,14 @@ namespace libtorrent
 		// if it is 0, the download rate limit setting
 		// will be used to determine if whole pieces
 		// are preferred.
-		std::uint8_t m_prefer_contiguous_blocks;
+		std::uint8_t m_prefer_contiguous_blocks = 0;
 
 		// this is the number of times this peer has had
 		// a request rejected because of a disk I/O failure.
 		// once this reaches a certain threshold, the
 		// peer is disconnected in order to avoid infinite
 		// loops of consistent failures
-		std::uint8_t m_disk_read_failures;
+		std::uint8_t m_disk_read_failures = 0;
 
 		// this is used in seed mode whenever we trigger a hash check
 		// for a piece, before we read it. It's used to throttle
@@ -1229,15 +1230,15 @@ namespace libtorrent
 
 #if TORRENT_USE_ASSERTS
 	public:
-		bool m_in_constructor;
+		bool m_in_constructor = true;
-		bool m_disconnect_started;
+		bool m_disconnect_started = false;
-		bool m_initialized;
+		bool m_initialized = false;
-		int m_in_use;
+		int m_in_use = 1337;
-		int m_received_in_piece;
+		int m_received_in_piece = 0;
-		bool m_destructed;
+		bool m_destructed = false;
 		// this is true while there is an outstanding
 		// async write job on the socket
-		bool m_socket_is_writing;
+		bool m_socket_is_writing = false;
 		bool is_single_thread() const;
 #endif
 	};

include/libtorrent/torrent.hpp

@@ -1147,8 +1147,8 @@ namespace libtorrent
 
 		// all time totals of uploaded and downloaded payload
 		// stored in resume data
-		std::int64_t m_total_uploaded;
+		std::int64_t m_total_uploaded = 0;
-		std::int64_t m_total_downloaded;
+		std::int64_t m_total_downloaded = 0;
 
 		// if this pointer is 0, the torrent is in
 		// a state where the metadata hasn't been
@@ -1289,14 +1289,14 @@ namespace libtorrent
 		// it was completed. If the torrent isn't yet
 		// completed, m_completed_time is 0
 		time_t m_added_time;
-		time_t m_completed_time;
+		time_t m_completed_time = 0;
 
 		// this was the last time _we_ saw a seed in this swarm
-		time_t m_last_seen_complete;
+		time_t m_last_seen_complete = 0;
 
 		// this is the time last any of our peers saw a seed
 		// in this swarm
-		time_t m_swarm_last_seen_complete;
+		time_t m_swarm_last_seen_complete = 0;
 
 		// keep a copy if the info-hash here, so it can be accessed from multiple
 		// threads, and be cheap to access from the client
@@ -1317,7 +1317,7 @@ namespace libtorrent
 	private:
 
 		// m_num_verified = m_verified.count()
-		std::uint32_t m_num_verified;
+		std::uint32_t m_num_verified = 0;
 
 		// this timestamp is kept in session-time, to
 		// make it fit in 16 bits
@@ -1335,23 +1335,23 @@ namespace libtorrent
 
 		// if we're a seed, this is the session time
 		// timestamp of when we became one
-		std::uint16_t m_became_seed;
+		std::uint16_t m_became_seed = 0;
 
 		// if we're finished, this is the session time
 		// timestamp of when we finished
-		std::uint16_t m_became_finished;
+		std::uint16_t m_became_finished = 0;
 
 		// when checking, this is the first piece we have not
 		// issued a hash job for
-		int m_checking_piece;
+		int m_checking_piece = 0;
 
 		// the number of pieces we completed the check of
-		int m_num_checked_pieces;
+		int m_num_checked_pieces = 0;
 
 		// the number of async. operations that need this torrent
 		// loaded in RAM. having a refcount > 0 prevents it from
 		// being unloaded.
-		int m_refcount;
+		int m_refcount = 0;
 
 		// if the error ocurred on a file, this is the index of that file
 		// there are a few special cases, when this is negative. See
@@ -1359,15 +1359,15 @@ namespace libtorrent
 		int m_error_file;
 
 		// the average time it takes to download one time critical piece
-		std::uint32_t m_average_piece_time;
+		std::uint32_t m_average_piece_time = 0;
 
 		// the average piece download time deviation
-		std::uint32_t m_piece_time_deviation;
+		std::uint32_t m_piece_time_deviation = 0;
 
 		// the number of bytes that has been
 		// downloaded that failed the hash-test
-		std::uint32_t m_total_failed_bytes;
+		std::uint32_t m_total_failed_bytes = 0;
-		std::uint32_t m_total_redundant_bytes;
+		std::uint32_t m_total_redundant_bytes = 0;
 
 		// the sequence number for this torrent, this is a
 		// monotonically increasing number for each added torrent
@@ -1375,14 +1375,14 @@ namespace libtorrent
 
 		// for torrents who have a bandwidth limit, this is != 0
 		// and refers to a peer_class in the session.
-		std::uint16_t m_peer_class;
+		std::uint16_t m_peer_class = 0;
 
 		// of all peers in m_connections, this is the number
 		// of peers that are outgoing and still waiting to
 		// complete the connection. This is used to possibly
 		// kick out these connections when we get incoming
 		// connections (if we've reached the connection limit)
-		std::uint16_t m_num_connecting;
+		std::uint16_t m_num_connecting = 0;
 
 		// ==============================
 		// The following members are specifically
@@ -1393,7 +1393,7 @@ namespace libtorrent
 
 		// the session time timestamp of when we entered upload mode
 		// if we're currently in upload-mode
-		std::uint16_t m_upload_mode_time;
+		std::uint16_t m_upload_mode_time = 0;
 
 		// true when this torrent should announce to
 		// trackers
@@ -1434,7 +1434,7 @@ namespace libtorrent
 		unsigned int m_active_time:24;
 
 		// the index to the last tracker that worked
-		std::int8_t m_last_working_tracker;
+		std::int8_t m_last_working_tracker = -1;
 
 // ----
 
@@ -1586,16 +1586,16 @@ namespace libtorrent
 		// the timestamp of the last piece passed for this torrent specified in
 		// session_time. This is signed because it must be able to represent time
 		// before the session started
-		std::int16_t m_last_download;
+		std::int16_t m_last_download = (std::numeric_limits<std::int16_t>::min)();
 
 		// the number of peer connections to seeds. This should be the same as
 		// counting the peer connections that say true for is_seed()
-		std::uint16_t m_num_seeds;
+		std::uint16_t m_num_seeds = 0;
 
 		// the timestamp of the last byte uploaded from this torrent specified in
 		// session_time. This is signed because it must be able to represent time
 		// before the session started.
-		std::int16_t m_last_upload;
+		std::int16_t m_last_upload = (std::numeric_limits<std::int16_t>::min)();
 
 // ----
 
@@ -1627,7 +1627,7 @@ namespace libtorrent
 		// the timestamp of the last scrape request to one of the trackers in
 		// this torrent specified in session_time. This is signed because it must
 		// be able to represent time before the session started
-		std::int16_t m_last_scrape;
+		std::int16_t m_last_scrape = (std::numeric_limits<std::int16_t>::min)();
 
 // ----
 
@@ -1637,8 +1637,8 @@ namespace libtorrent
 
 #if TORRENT_USE_ASSERTS
 		// set to true when torrent is start()ed. It may only be started once
-		bool m_was_started;
+		bool m_was_started = false;
-		bool m_outstanding_check_files;
+		bool m_outstanding_check_files = false;
 #endif
 	};
 

src/bt_peer_connection.cpp

@@ -156,7 +156,6 @@ namespace libtorrent
 	bt_peer_connection::bt_peer_connection(peer_connection_args const& pack
 		, peer_id const& pid)
 		: peer_connection(pack)
-		, m_state(read_protocol_identifier)
 		, m_supports_extensions(false)
 		, m_supports_dht_port(false)
 		, m_supports_fast(false)
@@ -169,20 +168,6 @@ namespace libtorrent
 		, m_recv_buffer(peer_connection::m_recv_buffer)
 #endif
 		, m_our_peer_id(pid)
-#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
-		, m_sync_bytes_read(0)
-#endif
-#ifndef TORRENT_DISABLE_EXTENSIONS
-		, m_upload_only_id(0)
-		, m_holepunch_id(0)
-#endif
-#ifndef TORRENT_DISABLE_EXTENSIONS
-		, m_dont_have_id(0)
-		, m_share_mode_id(0)
-#endif
-#if TORRENT_USE_ASSERTS
-		, m_in_constructor(true)
-#endif
 	{
 #ifndef TORRENT_DISABLE_LOGGING
 		peer_log(peer_log_alert::info, "CONSTRUCT", "bt_peer_connection");
@@ -262,7 +247,7 @@ namespace libtorrent
 			write_pe1_2_dhkey();
 			if (is_disconnecting()) return;
 
-			m_state = read_pe_dhkey;
+			m_state = state_t::read_pe_dhkey;
 			m_recv_buffer.reset(dh_key_len);
 			setup_receive();
 		}
@@ -284,7 +269,7 @@ namespace libtorrent
 
 				write_pe1_2_dhkey();
 				if (is_disconnecting()) return;
-				m_state = read_pe_dhkey;
+				m_state = state_t::read_pe_dhkey;
 				m_recv_buffer.reset(dh_key_len);
 				setup_receive();
 			}
@@ -324,7 +309,11 @@ namespace libtorrent
 		// we're still waiting to fully handshake with this peer. At the end of
 		// the handshake we'll send the bitfield and dht port anyway. It's too
 		// early to do now
-		if (m_state < read_packet_size) return;
+		if (static_cast<int>(m_state)
+			< static_cast<int>(state_t::read_packet_size))
+		{
+			return;
+		}
 
 		// connections that are still in the handshake
 		// will send their bitfield when the handshake
@@ -859,7 +848,7 @@ namespace libtorrent
 
 		span<char const> recv_buffer = m_recv_buffer.get();
 		// are we currently receiving a 'piece' message?
-		if (m_state != read_packet
+		if (m_state != state_t::read_packet
 			|| int(recv_buffer.size()) <= 9
 			|| recv_buffer[0] != msg_piece)
 			return boost::optional<piece_block_progress>();
@@ -2074,7 +2063,7 @@ namespace libtorrent
 
 		// if we have not received the other peer's extension bits yet, how do we
 		// know whether to send a have-all or have-none?
-		TORRENT_ASSERT(m_state >= read_peer_id);
+		TORRENT_ASSERT(m_state >= state_t::read_peer_id);
 
 		boost::shared_ptr<torrent> t = associated_torrent().lock();
 		TORRENT_ASSERT(t);
@@ -2575,7 +2564,7 @@ namespace libtorrent
 		// m_state is set to read_pe_dhkey in initial state
 		// (read_protocol_identifier) for incoming, or in constructor
 		// for outgoing
-		if (m_state == read_pe_dhkey)
+		if (m_state == state_t::read_pe_dhkey)
 		{
 			received_bytes(0, int(bytes_transferred));
 
@@ -2609,7 +2598,7 @@ namespace libtorrent
 
 			if (is_outgoing())
 			{
-				m_state = read_pe_syncvc;
+				m_state = state_t::read_pe_syncvc;
 				write_pe3_sync();
 
 				// initial payload is the standard handshake, this is
@@ -2626,7 +2615,7 @@ namespace libtorrent
 			else
 			{
 				// already written dh key
-				m_state = read_pe_synchash;
+				m_state = state_t::read_pe_synchash;
 				// synchash,skeyhash,vc,crypto_provide,len(pad),pad,encrypt(handshake)
 				m_recv_buffer.reset(20+20+8+4+2+0+handshake_len);
 			}
@@ -2635,7 +2624,7 @@ namespace libtorrent
 		}
 
 		// cannot fall through into
-		if (m_state == read_pe_synchash)
+		if (m_state == state_t::read_pe_synchash)
 		{
 			TORRENT_ASSERT(!m_encrypted);
 			TORRENT_ASSERT(!m_rc4_encrypted);
@@ -2702,7 +2691,7 @@ namespace libtorrent
 					, "sync point (hash) found at offset %d"
 					, int(m_sync_bytes_read + bytes_processed - 20));
 #endif
-				m_state = read_pe_skey_vc;
+				m_state = state_t::read_pe_skey_vc;
 				// skey,vc - 28 bytes
 				m_sync_hash.reset();
 				int transferred_used = int(bytes_processed - int(recv_buffer.size()) + bytes_transferred);
@@ -2713,7 +2702,7 @@ namespace libtorrent
 			}
 		}
 
-		if (m_state == read_pe_skey_vc)
+		if (m_state == state_t::read_pe_skey_vc)
 		{
 			received_bytes(0, int(bytes_transferred));
 			bytes_transferred = 0;
@@ -2773,12 +2762,12 @@ namespace libtorrent
 #ifndef TORRENT_DISABLE_LOGGING
 			peer_log(peer_log_alert::info, "ENCRYPTION", "verification constant found");
 #endif
-			m_state = read_pe_cryptofield;
+			m_state = state_t::read_pe_cryptofield;
 			m_recv_buffer.reset(4 + 2);
 		}
 
 		// cannot fall through into
-		if (m_state == read_pe_syncvc)
+		if (m_state == state_t::read_pe_syncvc)
 		{
 			TORRENT_ASSERT(is_outgoing());
 			TORRENT_ASSERT(!m_encrypted);
@@ -2849,12 +2838,12 @@ namespace libtorrent
 
 				// delete verification constant
 				m_sync_vc.reset();
-				m_state = read_pe_cryptofield;
+				m_state = state_t::read_pe_cryptofield;
 				// fall through
 			}
 		}
 
-		if (m_state == read_pe_cryptofield) // local/remote
+		if (m_state == state_t::read_pe_cryptofield) // local/remote
 		{
 			TORRENT_ASSERT(!m_encrypted);
 			TORRENT_ASSERT(!m_rc4_encrypted);
@@ -2942,7 +2931,7 @@ namespace libtorrent
 				return;
 			}
 
-			m_state = read_pe_pad;
+			m_state = state_t::read_pe_pad;
 			if (!is_outgoing())
 				m_recv_buffer.reset(len_pad + 2); // len(IA) at the end of pad
 			else
@@ -2955,14 +2944,14 @@ namespace libtorrent
 						switch_send_crypto(m_rc4);
 						switch_recv_crypto(m_rc4);
 					}
-					m_state = init_bt_handshake;
+					m_state = state_t::init_bt_handshake;
 				}
 				else
 					m_recv_buffer.reset(len_pad);
 			}
 		}
 
-		if (m_state == read_pe_pad)
+		if (m_state == state_t::read_pe_pad)
 		{
 			TORRENT_ASSERT(!m_encrypted);
 			received_bytes(0, int(bytes_transferred));
@@ -3001,11 +2990,11 @@ namespace libtorrent
 						switch_send_crypto(m_rc4);
 						switch_recv_crypto(m_rc4);
 					}
-					m_state = init_bt_handshake;
+					m_state = state_t::init_bt_handshake;
 				}
 				else
 				{
-					m_state = read_pe_ia;
+					m_state = state_t::read_pe_ia;
 					m_recv_buffer.reset(len_ia);
 				}
 			}
@@ -3018,11 +3007,11 @@ namespace libtorrent
 					switch_send_crypto(m_rc4);
 					switch_recv_crypto(m_rc4);
 				}
-				m_state = init_bt_handshake;
+				m_state = state_t::init_bt_handshake;
 			}
 		}
 
-		if (m_state == read_pe_ia)
+		if (m_state == state_t::read_pe_ia)
 		{
 			received_bytes(0, int(bytes_transferred));
 			bytes_transferred = 0;
@@ -3051,11 +3040,11 @@ namespace libtorrent
 			}
 			m_rc4.reset();
 
-			m_state = read_protocol_identifier;
+			m_state = state_t::read_protocol_identifier;
 			m_recv_buffer.cut(0, 20);
 		}
 
-		if (m_state == init_bt_handshake)
+		if (m_state == state_t::init_bt_handshake)
 		{
 			received_bytes(0, int(bytes_transferred));
 			bytes_transferred = 0;
@@ -3076,7 +3065,7 @@ namespace libtorrent
 			m_rc4.reset();
 
 			// payload stream, start with 20 handshake bytes
-			m_state = read_protocol_identifier;
+			m_state = state_t::read_protocol_identifier;
 			m_recv_buffer.reset(20);
 
 			// encrypted portion of handshake completed, toggle
@@ -3094,7 +3083,7 @@ namespace libtorrent
 
 #endif // #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
 
-		if (m_state == read_protocol_identifier)
+		if (m_state == state_t::read_protocol_identifier)
 		{
 			received_bytes(0, int(bytes_transferred));
 			bytes_transferred = 0;
@@ -3148,7 +3137,7 @@ namespace libtorrent
 #ifndef TORRENT_DISABLE_LOGGING
 				peer_log(peer_log_alert::info, "ENCRYPTION", "attempting encrypted connection");
 #endif
-				m_state = read_pe_dhkey;
+				m_state = state_t::read_pe_dhkey;
 				m_recv_buffer.cut(0, dh_key_len);
 				TORRENT_ASSERT(!m_recv_buffer.packet_finished());
 				return;
@@ -3160,7 +3149,7 @@ namespace libtorrent
 			else
 			{
 #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
-				TORRENT_ASSERT(m_state != read_pe_dhkey);
+				TORRENT_ASSERT(m_state != state_t::read_pe_dhkey);
 
 				if (!is_outgoing()
 					&& m_settings.get_int(settings_pack::in_enc_policy)
@@ -3178,12 +3167,12 @@ namespace libtorrent
 #endif
 			}
 
-			m_state = read_info_hash;
+			m_state = state_t::read_info_hash;
 			m_recv_buffer.reset(28);
 		}
 
 		// fall through
-		if (m_state == read_info_hash)
+		if (m_state == state_t::read_info_hash)
 		{
 			received_bytes(0, int(bytes_transferred));
 			bytes_transferred = 0;
@@ -3264,12 +3253,12 @@ namespace libtorrent
 
 			if (is_disconnecting()) return;
 
-			m_state = read_peer_id;
+			m_state = state_t::read_peer_id;
 			m_recv_buffer.reset(20);
 		}
 
 		// fall through
-		if (m_state == read_peer_id)
+		if (m_state == state_t::read_peer_id)
 		{
 			TORRENT_ASSERT(m_sent_handshake);
 			received_bytes(0, int(bytes_transferred));
@@ -3410,7 +3399,7 @@ namespace libtorrent
 				}
 			}
 
-			m_state = read_packet_size;
+			m_state = state_t::read_packet_size;
 			m_recv_buffer.reset(5);
 
 			TORRENT_ASSERT(!m_recv_buffer.packet_finished());
@@ -3418,7 +3407,7 @@ namespace libtorrent
 		}
 
 		// cannot fall through into
-		if (m_state == read_packet_size)
+		if (m_state == state_t::read_packet_size)
 		{
 			// Make sure this is not fallen though into
 			TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin());
@@ -3457,20 +3446,20 @@ namespace libtorrent
 				incoming_keepalive();
 				if (is_disconnecting()) return;
 				// keepalive message
-				m_state = read_packet_size;
+				m_state = state_t::read_packet_size;
 				m_recv_buffer.cut(4, 5);
 				return;
 			}
 			if (int(recv_buffer.size()) < 5) return;
 
-			m_state = read_packet;
+			m_state = state_t::read_packet;
 			m_recv_buffer.cut(4, packet_size);
 			recv_buffer = m_recv_buffer.get();
 			TORRENT_ASSERT(int(recv_buffer.size()) == 1);
 			TORRENT_ASSERT(bytes_transferred == 1);
 		}
 
-		if (m_state == read_packet)
+		if (m_state == state_t::read_packet)
 		{
 			TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin());
 			TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size());
@@ -3486,7 +3475,7 @@ namespace libtorrent
 #endif
 			if (dispatch_message(int(bytes_transferred)))
 			{
-				m_state = read_packet_size;
+				m_state = state_t::read_packet_size;
 				m_recv_buffer.reset(5);
 			}
 
@@ -3587,7 +3576,7 @@ namespace libtorrent
 		boost::shared_ptr<torrent> t = associated_torrent().lock();
 
 #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
-		TORRENT_ASSERT( (bool(m_state != read_pe_dhkey) || m_dh_key_exchange.get())
+		TORRENT_ASSERT( (bool(m_state != state_t::read_pe_dhkey) || m_dh_key_exchange.get())
 				|| !is_outgoing());
 
 		TORRENT_ASSERT(!m_rc4_encrypted || (!m_encrypted && m_rc4)

src/peer_connection.cpp

@@ -110,7 +110,6 @@ namespace libtorrent
 	}
 #endif
 
-	// outbound connection
 	peer_connection::peer_connection(peer_connection_args const& pack)
 		: peer_connection_hot_members(pack.tor, *pack.ses, *pack.sett)
 		, m_socket(pack.s)
@@ -123,42 +122,6 @@ namespace libtorrent
 		, m_allocator(*pack.allocator)
 		, m_ios(*pack.ios)
 		, m_work(m_ios)
-		, m_last_piece(aux::time_now())
-		, m_last_request(aux::time_now())
-		, m_last_incoming_request(min_time())
-		, m_last_unchoke(aux::time_now())
-		, m_last_unchoked(aux::time_now())
-		, m_last_choke(min_time())
-		, m_last_receive(aux::time_now())
-		, m_last_sent(aux::time_now())
-		, m_last_sent_payload(aux::time_now())
-		, m_requested(min_time())
-		, m_remote_dl_update(aux::time_now())
-		, m_connect(aux::time_now())
-		, m_became_uninterested(aux::time_now())
-		, m_became_uninteresting(aux::time_now())
-		, m_downloaded_at_last_round(0)
-		, m_uploaded_at_last_round(0)
-		, m_uploaded_at_last_unchoke(0)
-		, m_downloaded_last_second(0)
-		, m_uploaded_last_second(0)
-		, m_outstanding_bytes(0)
-		, m_last_seen_complete(0)
-		, m_receiving_block(piece_block::invalid)
-		, m_extension_outstanding_bytes(0)
-		, m_queued_time_critical(0)
-		, m_reading_bytes(0)
-		, m_picker_options(0)
-		, m_num_invalid_requests(0)
-		, m_remote_pieces_dled(0)
-		, m_remote_dl_rate(0)
-		, m_outstanding_writing_bytes(0)
-		, m_download_rate_peak(0)
-		, m_upload_rate_peak(0)
-		, m_send_barrier(INT_MAX)
-		, m_desired_queue_size(4)
-		, m_prefer_contiguous_blocks(0)
-		, m_disk_read_failures(0)
 		, m_outstanding_piece_verification(0)
 		, m_outgoing(!pack.tor.expired())
 		, m_received_listen_port(false)
@@ -178,15 +141,6 @@ namespace libtorrent
 		, m_has_metadata(true)
 		, m_exceeded_limit(false)
 		, m_slow_start(true)
-#if TORRENT_USE_ASSERTS
-		, m_in_constructor(true)
-		, m_disconnect_started(false)
-		, m_initialized(false)
-		, m_in_use(1337)
-		, m_received_in_piece(0)
-		, m_destructed(false)
-		, m_socket_is_writing(false)
-#endif
 	{
 		m_counters.inc_stats_counter(counters::num_tcp_peers + m_socket->type() - 1);
 
@@ -195,8 +149,6 @@ namespace libtorrent
 		else if (m_connecting)
 			m_counters.inc_stats_counter(counters::num_peers_half_open);
 
-		m_superseed_piece[0] = -1;
-		m_superseed_piece[1] = -1;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		// if t is nullptr, we better not be connecting, since
 		// we can't decrement the connecting counter
@@ -5866,12 +5818,13 @@ namespace libtorrent
 					disconnect(ec, op_sock_read);
 					return;
 				}
-
+				else
+				{
 					account_received_bytes(bytes);
-
 					bytes_transferred += bytes;
 				}
 			}
+		}
 
 		// feed bytes in receive buffer to upper layer by calling on_receive()
 

src/session_impl.cpp

@@ -305,26 +305,15 @@ namespace aux {
 #endif
 
 	session_impl::session_impl(io_service& ios)
-		:
+		: m_io_service(ios)
-#ifndef TORRENT_DISABLE_POOL_ALLOCATOR
-		m_send_buffers(send_buffer_size())
-		,
-#endif
-		m_io_service(ios)
 #ifdef TORRENT_USE_OPENSSL
 		, m_ssl_ctx(m_io_service, boost::asio::ssl::context::sslv23)
 #endif
 		, m_alerts(m_settings.get_int(settings_pack::alert_queue_size), alert::all_categories)
-#ifndef TORRENT_NO_DEPRECATE
-		, m_alert_pointer_pos(0)
-#endif
 		, m_disk_thread(m_io_service, m_stats_counters
 			, static_cast<uncork_interface*>(this))
 		, m_download_rate(peer_connection::download_channel)
 		, m_upload_rate(peer_connection::upload_channel)
-		, m_global_class(0)
-		, m_tcp_peer_class(0)
-		, m_local_peer_class(0)
 		, m_tracker_manager(
 			std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4)
 			, std::bind(&session_impl::send_udp_packet_hostname, this, _1, _2, _3, _4, _5)
@@ -336,31 +325,16 @@ namespace aux {
 #endif
 			)
 		, m_work(io_service::work(m_io_service))
-		, m_max_queue_pos(-1)
-		, m_key(0)
 #if TORRENT_USE_I2P
 		, m_i2p_conn(m_io_service)
 #endif
-		, m_socks_listen_port(0)
-		, m_interface_index(0)
-		, m_unchoke_time_scaler(0)
-		, m_auto_manage_time_scaler(0)
-		, m_optimistic_unchoke_time_scaler(0)
-		, m_disconnect_time_scaler(90)
-		, m_auto_scrape_time_scaler(180)
-		, m_peak_up_rate(0)
-		, m_peak_down_rate(0)
 		, m_created(clock_type::now())
 		, m_last_tick(m_created)
 		, m_last_second_tick(m_created - milliseconds(900))
 		, m_last_choke(m_created)
 		, m_last_auto_manage(m_created)
-		, m_next_port(0)
 #ifndef TORRENT_DISABLE_DHT
-		, m_dht_storage_constructor(dht::dht_default_storage_constructor)
 		, m_dht_announce_timer(m_io_service)
-		, m_dht_interval_update_torrents(0)
-		, m_outstanding_router_lookups(0)
 #endif
 		, m_utp_socket_manager(
 			std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4)
@@ -375,25 +349,10 @@ namespace aux {
 			, m_settings, m_stats_counters
 			, &m_ssl_ctx)
 #endif
-		, m_boost_connections(0)
 		, m_timer(m_io_service)
 		, m_lsd_announce_timer(m_io_service)
 		, m_host_resolver(m_io_service)
-		, m_next_downloading_connect_torrent(0)
-		, m_next_finished_connect_torrent(0)
-		, m_download_connect_attempts(0)
-		, m_next_scrape_torrent(0)
-		, m_tick_residual(0)
-		, m_deferred_submit_disk_jobs(false)
-		, m_pending_auto_manage(false)
-		, m_need_auto_manage(false)
-		, m_abort(false)
-		, m_paused(false)
 	{
-#if TORRENT_USE_ASSERTS
-		m_posting_torrent_updates = false;
-#endif
-
 		update_time_now();
 	}
 
@@ -447,9 +406,6 @@ namespace aux {
 		m_peer_class_type_filter.add(peer_class_type_filter::ssl_tcp_socket, m_tcp_peer_class);
 		m_peer_class_type_filter.add(peer_class_type_filter::i2p_socket, m_tcp_peer_class);
 
-		// TODO: there's no rule here to make uTP connections not have the global or
-		// local rate limits apply to it. This used to be the default.
-
 #ifndef TORRENT_DISABLE_LOGGING
 
 		session_log("config: %s version: %s revision: %s"
@@ -471,7 +427,6 @@ namespace aux {
 #ifndef TORRENT_DISABLE_LOGGING
 		session_log("   max connections: %d", m_settings.get_int(settings_pack::connections_limit));
 		session_log("   max files: %d", max_files);
-
 		session_log(" generated peer ID: %s", m_peer_id.to_string().c_str());
 #endif
 

src/torrent.cpp

@@ -183,8 +183,6 @@ namespace libtorrent
 		, add_torrent_params const& p
 		, sha1_hash const& info_hash)
 		: torrent_hot_members(ses, p, block_size, session_paused)
-		, m_total_uploaded(0)
-		, m_total_downloaded(0)
 		, m_tracker_timer(ses.get_io_service())
 		, m_inactivity_timer(ses.get_io_service())
 		, m_trackerid(p.trackerid)
@@ -197,27 +195,11 @@ namespace libtorrent
 		, m_stats_counters(ses.stats_counters())
 		, m_storage_constructor(p.storage)
 		, m_added_time(time(nullptr))
-		, m_completed_time(0)
-		, m_last_seen_complete(0)
-		, m_swarm_last_seen_complete(0)
 		, m_info_hash(info_hash)
-		, m_num_verified(0)
 		, m_last_saved_resume(ses.session_time())
 		, m_started(ses.session_time())
-		, m_became_seed(0)
-		, m_became_finished(0)
-		, m_checking_piece(0)
-		, m_num_checked_pieces(0)
-		, m_refcount(0)
 		, m_error_file(torrent_status::error_file_none)
-		, m_average_piece_time(0)
-		, m_piece_time_deviation(0)
-		, m_total_failed_bytes(0)
-		, m_total_redundant_bytes(0)
 		, m_sequence_number(seq)
-		, m_peer_class(0)
-		, m_num_connecting(0)
-		, m_upload_mode_time(0)
 		, m_announce_to_trackers((p.flags & add_torrent_params::flag_paused) == 0)
 		, m_announce_to_lsd((p.flags & add_torrent_params::flag_paused) == 0)
 		, m_has_incoming(false)
@@ -226,7 +208,6 @@ namespace libtorrent
 		, m_announcing(false)
 		, m_waiting_tracker(false)
 		, m_active_time(0)
-		, m_last_working_tracker(-1)
 		, m_finished_time(0)
 		, m_sequential_download(false)
 		, m_auto_sequential(false)
@@ -254,20 +235,12 @@ namespace libtorrent
 		, m_deleted(false)
 		, m_pinned((p.flags & add_torrent_params::flag_pinned) != 0)
 		, m_should_be_loaded(true)
-		, m_last_download((std::numeric_limits<std::int16_t>::min)())
-		, m_num_seeds(0)
-		, m_last_upload((std::numeric_limits<std::int16_t>::min)())
 		, m_auto_managed((p.flags & add_torrent_params::flag_auto_managed) != 0)
 		, m_current_gauge_state(no_gauge_state)
 		, m_moving_storage(false)
 		, m_inactive(false)
 		, m_downloaded(0xffffff)
-		, m_last_scrape((std::numeric_limits<std::int16_t>::min)())
 		, m_progress_ppm(0)
-#if TORRENT_USE_ASSERTS
-		, m_was_started(false)
-		, m_outstanding_check_files(false)
-#endif
 	{
 		// we cannot log in the constructor, because it relies on shared_from_this
 		// being initialized, which happens after the constructor returns.