Revert 224269 "Don't persist HPKP if PrivacyMode is enabled."

trunk/src/net/websockets/websocket_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/websockets/websocket_job.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 349 matching lines @@
 
   // handshake message is completed.
   handshake_response_->set_protocol_version(
       handshake_request_->protocol_version());
   AddCookieHeaderAndSend();
   return true;
 }
 
 void WebSocketJob::AddCookieHeaderAndSend() {
   bool allow = true;
-  GURL url_for_cookies(socket_->url_for_cookies());
-  if (delegate_ && !delegate_->CanGetCookies(socket_.get(), url_for_cookies))
+  if (delegate_ && !delegate_->CanGetCookies(socket_.get(), GetURLForCookies()))
     allow = false;
 
   if (socket_.get() && delegate_ && state_ == CONNECTING) {
     handshake_request_->RemoveHeaders(kCookieHeaders,
                                       arraysize(kCookieHeaders));
     if (allow && socket_->context()->cookie_store()) {
       // Add cookies, including HttpOnly cookies.
       CookieOptions cookie_options;
       cookie_options.set_include_httponly();
       socket_->context()->cookie_store()->GetCookiesWithOptionsAsync(
-          url_for_cookies,
-          cookie_options,
+          GetURLForCookies(), cookie_options,
           base::Bind(&WebSocketJob::LoadCookieCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       DoSendData();
     }
   }
 }
 
 void WebSocketJob::LoadCookieCallback(const std::string& cookie) {
   if (!cookie.empty())
@@ skipping 110 matching lines @@
 }
 
 void WebSocketJob::SaveNextCookie() {
   if (!socket_.get() || !delegate_ || state_ != CONNECTING)
     return;
 
   callback_pending_ = false;
   save_next_cookie_running_ = true;
 
   if (socket_->context()->cookie_store()) {
-    GURL url_for_cookies(socket_->url_for_cookies());
+    GURL url_for_cookies = GetURLForCookies();
 
     CookieOptions options;
     options.set_include_httponly();
 
     // Loop as long as SetCookieWithOptionsAsync completes synchronously. Since
     // CookieMonster's asynchronous operation APIs queue the callback to run it
     // on the thread where the API was called, there won't be race. I.e. unless
     // the callback is run synchronously, it won't be run in parallel with this
     // method.
     while (!callback_pending_ &&
@@ skipping 33 matching lines @@
   callback_pending_ = false;
 
   // Resume SaveNextCookie if the caller of SetCookieWithOptionsAsync() exited
   // the loop. Otherwise, return.
   if (save_next_cookie_running_)
     return;
 
   SaveNextCookie();
 }
 
+GURL WebSocketJob::GetURLForCookies() const {
+  GURL url = socket_->url();
+  std::string scheme = socket_->is_secure() ? "https" : "http";
+  url_canon::Replacements<char> replacements;
+  replacements.SetScheme(scheme.c_str(),
+                         url_parse::Component(0, scheme.length()));
+  return url.ReplaceComponents(replacements);
+}
+
 const AddressList& WebSocketJob::address_list() const {
   return addresses_;
 }
 
 int WebSocketJob::TrySpdyStream() {
   if (!socket_.get())
     return ERR_FAILED;
 
   if (!websocket_over_spdy_enabled_)
     return OK;
@@ skipping 110 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ =
       new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net