Disable 0RTT if server and origin have different hosts.

net/quic/quic_stream_factory.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_QUIC_STREAM_FACTORY_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 40 matching lines @@
 // cancel the request with the factory.
 class NET_EXPORT_PRIVATE QuicStreamRequest {
  public:
   explicit QuicStreamRequest(QuicStreamFactory* factory);
   ~QuicStreamRequest();
 
   // For http, |is_https| is false.
   int Request(const HostPortPair& host_port_pair,
               bool is_https,
               PrivacyMode privacy_mode,
+              base::StringPiece origin_host,
               base::StringPiece method,
               const BoundNetLog& net_log,
               const CompletionCallback& callback);
 
   void OnRequestComplete(int rv);
 
   scoped_ptr<QuicHttpStream> ReleaseStream();
 
   void set_stream(scoped_ptr<QuicHttpStream> stream);
 
   const BoundNetLog& net_log() const{
     return net_log_;
   }
 
  private:
   QuicStreamFactory* factory_;
   HostPortPair host_port_pair_;
+  std::string origin_host_;
   BoundNetLog net_log_;
   CompletionCallback callback_;
   scoped_ptr<QuicHttpStream> stream_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamRequest);
 };
 
 // A factory for creating new QuicHttpStreams on top of a pool of
 // QuicClientSessions.
 class NET_EXPORT_PRIVATE QuicStreamFactory
@@ skipping 27 matching lines @@
   ~QuicStreamFactory() override;
 
   // Creates a new QuicHttpStream to |host_port_pair| which will be
   // owned by |request|. |is_https| specifies if the protocol is https or not.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const HostPortPair& host_port_pair,
              bool is_https,
              PrivacyMode privacy_mode,
+             bool server_and_origin_have_same_host,
              base::StringPiece method,
              const BoundNetLog& net_log,
              QuicStreamRequest* request);
 
   // Returns false if |packet_loss_rate| is less than |packet_loss_threshold_|
   // otherwise it returns true and closes the session and marks QUIC as recently
   // broken for the port of the session. Increments
   // |number_of_lossy_connections_| by port.
   bool OnHandshakeConfirmed(QuicClientSession* session, float packet_loss_rate);
 
@@ skipping 132 matching lines @@
   // |crypto_config_| with the information in |server_info|.
   void InitializeCachedStateInCryptoConfig(
       const QuicServerId& server_id,
       const scoped_ptr<QuicServerInfo>& server_info);
 
   void ProcessGoingAwaySession(QuicClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
   bool require_confirmation_;
+  // True iff server and origin have the same hostname.

[Ryan Hamilton, 2015/05/18 14:29:52]

nit: iff is not very common in comments. I think "if" is fine.

[Bence, 2015/05/18 15:17:55]

I am fine with not using iff if it is not common enough, but in that case, I
prefer to spell out "if and only if" to very specificly convey what I actually
mean.

BTW it is now moot in this file.

[Ryan Hamilton, 2015/05/18 16:21:54]

Yeah, I totally understand the sentiment. It seems, though, that "and only if"
is pretty much implicit in how if is used in comments. For example:

* True if this is a post request
* True if handshake confirmation is required
* True if QUIC is disabled
* True if QUIC was recently broken

All of these are really "iff" but for some reason it seems fine to leave them
out. 

Perhaps this is because programmers are lazy while mathematicians are precise?
:>

[Bence, 2015/05/18 18:12:02]

I totally agree.  However, it is not clear to me after all if you mind me
writing "if and only if", so I'll leave it as that for the time being.  Feel
free to ask me to change if you prefer.  Thanks.

+  bool server_and_origin_have_same_host_;

[Ryan Hamilton, 2015/05/18 14:29:52]

Wait, this is surprising. This is a member of the factory, not a job. That
doesn't seem right to me. The factory deal with lots of requests/sessions/jobs
at once. Which does this member apply to?

[Bence, 2015/05/18 15:17:55]

Good catch, sorry about that.  Done.

   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
   base::WeakPtr<HttpServerProperties> http_server_properties_;
   TransportSecurityState* transport_security_state_;
   QuicServerInfoFactory* quic_server_info_factory_;
   QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
   QuicRandom* random_generator_;
   scoped_ptr<QuicClock> clock_;
   const size_t max_packet_length_;
 
@@ skipping 82 matching lines @@
   base::TaskRunner* task_runner_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_