Add cross origin to Blink-driven preconnect

chrome/browser/net/preconnect.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 "chrome/browser/net/preconnect.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "content/public/browser/browser_thread.h"
+#include "net/base/load_flags.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/log/net_log.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
 void PreconnectOnUIThread(
     const GURL& url,
     const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
     int count,
     net::URLRequestContextGetter* getter) {
   // Prewarm connection to Search URL.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&PreconnectOnIOThread, url, first_party_for_cookies,
-                 motivation, count, make_scoped_refptr(getter)));
+                 motivation, count, make_scoped_refptr(getter), false));
   return;
 }
 
 
 void PreconnectOnIOThread(
     const GURL& url,
     const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
     int count,
-    net::URLRequestContextGetter* getter) {
+    net::URLRequestContextGetter* getter,
+    bool is_credentials_flag_set) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     LOG(DFATAL) << "This must be run only on the IO thread.";
     return;
   }
   if (!getter)
     return;
   // We are now commited to doing the async preconnection call.
   UMA_HISTOGRAM_ENUMERATION("Net.PreconnectMotivation", motivation,
                             UrlInfo::MAX_MOTIVATED);
 
   net::URLRequestContext* context = getter->GetURLRequestContext();
   net::HttpTransactionFactory* factory = context->http_transaction_factory();
   net::HttpNetworkSession* session = factory->GetSession();
 
   std::string user_agent;
   if (context->http_user_agent_settings())
     user_agent = context->http_user_agent_settings()->GetUserAgent();
   net::HttpRequestInfo request_info;
   request_info.url = url;
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kUserAgent,
                                        user_agent);
 
   net::NetworkDelegate* delegate = context->network_delegate();
-  if (delegate->CanEnablePrivacyMode(url, first_party_for_cookies))
+  if (delegate->CanEnablePrivacyMode(url, first_party_for_cookies)
+    || !is_credentials_flag_set)

[Ryan Sleevi, 2015/06/11 22:20:15]

To be clear: You're going to need to dig in to why this doesn't work for your
test, what the root cause is, and what may need to change.

Using this bool to set privacy_mode_enabled, even if it causes the correct
behaviour, isn't consistent with the API contract. You shouldn't be setting this
yourself - it's //net's responsibility to do that based on the cookie settings
and load flags (fwiw, it's here -
https://code.google.com/p/chromium/codesearch#chromium/src/net/url_request/ur...
)

If I were a betting man, it's because HttpStreamFactory::PreconnectStreams
likely isn't aware of the UrlRequestHttpJob (which builds atop the
HttpStreamFactory, and is thus a higher layer), and as a result, is bypassing
the code I just linked. Because of this, even though you 'should' be in privacy
mode, you're not.

The existing lines of this file (lines 71/72) of this are weird, because they're
violating the layering of the UrlRequestHttpInfo.

I'll have to think about this and talk it over with some folks to see what the
thoughts are. It's possible we may just say "whatever" and let this code
through, or it may be that we say "Push this down a layer first" as part of the
'leave the code cleaner'.

My own instinct is that if we're going to properly enshrine things, what we
probably want to do is push this logic into PreconnectStreams (really, the
HttpStreamFactory), which means that it needs to touch the NetworkDelegate (it
already can), and would need both |url| and |first_party_for_cookies| URLs
pushed into it (the same as UrlRequestHttpJob does, ish).

Just making sure to document the thinking here

     request_info.privacy_mode = net::PRIVACY_MODE_ENABLED;
 
   // It almost doesn't matter whether we use net::LOWEST or net::HIGHEST
   // priority here, as we won't make a request, and will surrender the created
   // socket to the pool as soon as we can.  However, we would like to mark the
   // speculative socket as such, and IF we use a net::LOWEST priority, and if
   // a navigation asked for a socket (after us) then it would get our socket,
   // and we'd get its later-arriving socket, which might make us record that
   // the speculation didn't help :-/.  By using net::HIGHEST, we ensure that
   // a socket is given to us if "we asked first" and this allows us to mark it
@@ skipping 29 matching lines @@
 
   // All preconnects should perform EV certificate verification.
   ssl_config.verify_ev_cert = true;
 
   net::HttpStreamFactory* http_stream_factory = session->http_stream_factory();
   http_stream_factory->PreconnectStreams(count, request_info, priority,
                                          ssl_config, ssl_config);
 }
 
 }  // namespace chrome_browser_net