Don't persist HPKP if PrivacyMode is enabled.

net/socket_stream/socket_stream_job.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/socket_stream/socket_stream_job.h"
 
 #include "base/memory/singleton.h"
 #include "net/http/transport_security_state.h"
 #include "net/socket_stream/socket_stream_job_manager.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 // static
 SocketStreamJob::ProtocolFactory* SocketStreamJob::RegisterProtocolFactory(
     const std::string& scheme, ProtocolFactory* factory) {
   return SocketStreamJobManager::GetInstance()->RegisterProtocolFactory(
       scheme, factory);
 }
 
 // static
 SocketStreamJob* SocketStreamJob::CreateSocketStreamJob(
     const GURL& url,
     SocketStream::Delegate* delegate,
     TransportSecurityState* sts,
     SSLConfigService* ssl) {
   GURL socket_url(url);
   TransportSecurityState::DomainState domain_state;
-  if (url.scheme() == "ws" && sts && sts->GetDomainState(
-          url.host(), SSLConfigService::IsSNIAvailable(ssl), &domain_state) &&
+  if (url.scheme() == "ws" && sts &&
+      sts->GetDomainState(url.host(),
+                          SSLConfigService::IsSNIAvailable(ssl),
+                          delegate->CanGetCookies(NULL, url),

[Ryan Sleevi, 2013/08/06 22:32:11]

See remark about url needing to be scheme-fixed.

(It's also a really sucky layering here that StreamSocketJob has to know about
WebSockets, which sit atop net/socket_stream)

[mef, 2013/08/09 17:04:05]

Sorry, could you elaborate a little? I'm sure you are right, I'm just not sure
what needs to be done. :-)

[Ryan Sleevi, 2013/09/13 22:14:48]

Well, rather than having StreamSocket::CreateSocketStreamJob handle ws -> wss
fixup, the higher layer could do it.

Likewise, rather than having SocketStream fixup ws->http(s), have the delegate
do so.

[mef, 2013/09/16 15:00:08]

Hmm, higher level from here is SocketStreamHost and I'm not sure why moving
ws->wss fix up there would make it less confusing. It doesn't seem to care about
url details at this moment.
AFAIU delegate can have multiple different implementations now and in the future
and I'm not sure that expecting it to handle ws(s) vs http(s) correctly is a
good idea. 

[Ryan Sleevi, 2013/09/17 18:53:03]

Well, the only implementation that would/should have to worry about ws(s) vs
http(s) would be ones that supported WebSockets - which would be the right
abstraction to keeping the websocket knowledge 'out' of this.

However, it's clear that this class is *only* used in context of WebSockets (yay
confusing/weird designs), so I'm OK with this - and looking forward to the point
where WebSockets are better integrated.

+                          &domain_state) &&
       domain_state.ShouldUpgradeToSSL()) {
     url_canon::Replacements<char> replacements;
     static const char kNewScheme[] = "wss";
     replacements.SetScheme(kNewScheme,
                            url_parse::Component(0, strlen(kNewScheme)));
     socket_url = url.ReplaceComponents(replacements);
   }
   return SocketStreamJobManager::GetInstance()->CreateJob(socket_url, delegate);
 }
 
@@ skipping 36 matching lines @@
   socket_->ContinueDespiteError();
 }
 
 void SocketStreamJob::DetachDelegate() {
   socket_->DetachDelegate();
 }
 
 SocketStreamJob::~SocketStreamJob() {}
 
 }  // namespace net