Remove an unused QuicStreamFactory::Job constructor

net/quic/chromium/quic_stream_factory.cc

 // Copyright (c) 2012 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 "net/quic/chromium/quic_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 268 matching lines @@
   void OnComplete() {
     UMA_HISTOGRAM_TIMES("Net.QuicSession.CertVerifierJob.CompleteTime",
                         base::TimeTicks::Now() - start_time_);
     if (!callback_.is_null())
       base::ResetAndReturn(&callback_).Run(OK);
   }
 
   const QuicServerId& server_id() const { return server_id_; }
 
  private:
-  QuicServerId server_id_;
+  const QuicServerId server_id_;
   ProofVerifierCallbackImpl* verify_callback_;
   std::unique_ptr<ProofVerifyContext> verify_context_;
   std::unique_ptr<ProofVerifyDetails> verify_details_;
   std::string verify_error_details_;
-  base::TimeTicks start_time_;
+  const base::TimeTicks start_time_;
   const NetLogWithSource net_log_;
   CompletionCallback callback_;
   base::WeakPtrFactory<CertVerifierJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CertVerifierJob);
 };
 
 // Responsible for creating a new QUIC session to the specified server, and
 // for notifying any associated requests when complete.
 class QuicStreamFactory::Job {
@@ skipping 47 matching lines @@
     STATE_LOAD_SERVER_INFO_COMPLETE,
     STATE_CONNECT,
     STATE_RESUME_CONNECT,
     STATE_CONNECT_COMPLETE,
   };
   IoState io_state_;
 
   QuicStreamFactory* factory_;
   HostResolver* host_resolver_;
   std::unique_ptr<HostResolver::Request> request_;
-  QuicSessionKey key_;
-  int cert_verify_flags_;
-  bool was_alternative_service_recently_broken_;
+  const QuicSessionKey key_;
+  const int cert_verify_flags_;
+  const bool was_alternative_service_recently_broken_;
   std::unique_ptr<QuicServerInfo> server_info_;
   bool started_another_job_;
   const NetLogWithSource net_log_;
   int num_sent_client_hellos_;
   QuicChromiumClientSession* session_;
   CompletionCallback callback_;
   AddressList address_list_;
   base::TimeTicks dns_resolution_start_time_;
   base::TimeTicks dns_resolution_end_time_;
   base::WeakPtrFactory<Job> weak_factory_;
@@ skipping 14 matching lines @@
       cert_verify_flags_(cert_verify_flags),
       was_alternative_service_recently_broken_(
           was_alternative_service_recently_broken),
       server_info_(std::move(server_info)),
       started_another_job_(false),
       net_log_(net_log),
       num_sent_client_hellos_(0),
       session_(nullptr),
       weak_factory_(this) {}
 
-QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
-                            HostResolver* host_resolver,
-                            QuicChromiumClientSession* session,
-                            const QuicSessionKey& key)
-    : io_state_(STATE_RESUME_CONNECT),
-      factory_(factory),
-      host_resolver_(host_resolver),  // unused
-      key_(key),
-      cert_verify_flags_(0),                            // unused
-      was_alternative_service_recently_broken_(false),  // unused
-      started_another_job_(false),                      // unused
-      net_log_(session->net_log()),                     // unused
-      num_sent_client_hellos_(0),
-      session_(session),
-      weak_factory_(this) {}

[Zhongyi Shi, 2017/04/05 00:00:29]

Tracing the history of this code, this Job was used when we tried resume
connection if the 0RTT handshake had timed out. We don't have that logic anymore
in the current world. You might want to remove the code for RESUME_CONNECT as
well. 

https://codereview.chromium.org/318993004/

[Ryan Hamilton, 2017/04/05 00:10:10]

Nice catch, both of you. I agree with this suggestion.

[xunjieli, 2017/04/05 15:07:29]

Done. Good catch! The tests added in that CL are all passing, so I didn't touch
them. PTAL.

-
 QuicStreamFactory::Job::~Job() {
   DCHECK(callback_.is_null());
 
   // If disk cache has a pending WaitForDataReadyCallback, cancel that callback.
   if (server_info_)
     server_info_->ResetWaitForDataReadyCallback();
 }
 
 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) {
   int rv = DoLoop(OK);
@@ skipping 1564 matching lines @@
 void QuicStreamFactory::OpenFactory() {
   status_ = OPEN;
 }
 
 void QuicStreamFactory::MaybeClearConsecutiveDisabledCount() {
   if (status_ == OPEN)
     consecutive_disabled_count_ = 0;
 }
 
 }  // namespace net