QUIC - use QuicSessionKey tuple (host, port, is_https) instead of server_hostname

net/http/disk_cache_based_quic_server_info.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 "net/http/disk_cache_based_quic_server_info.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
+#include "net/quic/quic_session_key.h"
 
 namespace net {
 
 // Some APIs inside disk_cache take a handle that the caller must keep alive
 // until the API has finished its asynchronous execution.
 //
 // Unfortunately, DiskCacheBasedQuicServerInfo may be deleted before the
 // operation completes causing a use-after-free.
 //
 // This data shim struct is meant to provide a location for the disk_cache
@@ skipping 11 matching lines @@
 //
 // TODO(ajwong): Change disk_cache's API to return results via Callback.
 struct DiskCacheBasedQuicServerInfo::CacheOperationDataShim {
   CacheOperationDataShim() : backend(NULL), entry(NULL) {}
 
   disk_cache::Backend* backend;
   disk_cache::Entry* entry;
 };
 
 DiskCacheBasedQuicServerInfo::DiskCacheBasedQuicServerInfo(
-    const std::string& hostname,
+    const QuicSessionKey& server_key,
     HttpCache* http_cache)
-    : QuicServerInfo(hostname),
+    : QuicServerInfo(server_key),
       weak_factory_(this),
       data_shim_(new CacheOperationDataShim()),
       io_callback_(
           base::Bind(&DiskCacheBasedQuicServerInfo::OnIOComplete,
                      weak_factory_.GetWeakPtr(),
                      base::Owned(data_shim_))),  // Ownership assigned.
       state_(GET_BACKEND),
       ready_(false),
       found_entry_(false),
-      hostname_(hostname),
+      server_key_(server_key),
       http_cache_(http_cache),
       backend_(NULL),
       entry_(NULL) {
 }
 
 void DiskCacheBasedQuicServerInfo::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(GET_BACKEND, state_);
   DoLoop(OK);
 }
@@ skipping 37 matching lines @@
   DoLoop(OK);
 }
 
 DiskCacheBasedQuicServerInfo::~DiskCacheBasedQuicServerInfo() {
   DCHECK(user_callback_.is_null());
   if (entry_)
     entry_->Close();
 }
 
 std::string DiskCacheBasedQuicServerInfo::key() const {
-  return "quicserverinfo:" + hostname_;
+  return "quicserverinfo:" + server_key_.ToString();
 }
 
 void DiskCacheBasedQuicServerInfo::OnIOComplete(CacheOperationDataShim* unused,
                                                 int rv) {
   DCHECK_NE(NONE, state_);
   rv = DoLoop(rv);
   if (rv != ERR_IO_PENDING && !user_callback_.is_null()) {
     CompletionCallback callback = user_callback_;
     user_callback_.Reset();
     callback.Run(rv);
@@ skipping 152 matching lines @@
 int DiskCacheBasedQuicServerInfo::DoSetDone() {
   if (entry_)
     entry_->Close();
   entry_ = NULL;
   new_data_.clear();
   state_ = NONE;
   return OK;
 }
 
 }  // namespace net