Add cross origin to Blink-driven preconnect

chrome/browser/net/predictor.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/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
@@ skipping 69 matching lines @@
 const int Predictor::kMaxUnusedSocketLifetimeSecondsWithoutAGet = 10;
 // To control our congestion avoidance system, which discards a queue when
 // resolutions are "taking too long," we need an expected resolution time.
 // Common average is in the range of 300-500ms.
 const int kExpectedResolutionTimeMs = 500;
 const int Predictor::kTypicalSpeculativeGroupSize = 8;
 const int Predictor::kMaxSpeculativeResolveQueueDelayMs =
     (kExpectedResolutionTimeMs * Predictor::kTypicalSpeculativeGroupSize) /
     Predictor::kMaxSpeculativeParallelResolves;
 
+// The default value of the credentials flag when preconnecting.
+static bool kAllowCredentialsOnPreconnectByDefault = true;

[Ryan Sleevi, 2015/07/10 09:46:45]

I'm still not sure why this static bool. When I read it, I keep thinking "Oh,
this is a static bool that may change in future releases" (the whole aspect of
'ByDefault'). Can you just confirm that this isn't - this is just is just
re-using the constant?

If so, does it make more sense to put these values directly in the calls (and
not use the static)? It's unclear whether or not there is a specific
relationship between the various places that use this - that is, if you change
one of these calls, do all the others need to change? Or is it a case by case
basis?

[Yoav Weiss, 2015/07/10 10:03:40]

Yes, it is just about re-using the constant. 
They all simply call PreconnectUrl{,OnIOThread} which by default should allow
credentials.
That's not something that we want to change AFAIK, so I think a const/static is
more appropriate (since we don't like default parameter values :D)

But I can also add direct "true" values to the calls themselves, if you think
it's significantly better.

+
 static int g_max_queueing_delay_ms =
     Predictor::kMaxSpeculativeResolveQueueDelayMs;
 static size_t g_max_parallel_resolves =
     Predictor::kMaxSpeculativeParallelResolves;
 
 // A version number for prefs that are saved. This should be incremented when
 // we change the format so that we discard old data.
 static const int kPredictorStartupFormatVersion = 1;
 
 class Predictor::LookupRequest {
@@ skipping 158 matching lines @@
         // pool.  Currently, we just do a connect, which MAY be reset if we
         // don't use it in 10 secondes!!!  As a result, we may do more
         // connections, and actually cost the server more than if we did a real
         // get with a fake request (/gen_204 might be the good path on Google).
         const int kMaxSearchKeepaliveSeconds(10);
         if ((now - last_omnibox_preconnect_).InSeconds() <
             kMaxSearchKeepaliveSeconds)
           return;  // We've done a preconnect recently.
         last_omnibox_preconnect_ = now;
         const int kConnectionsNeeded = 1;
-        PreconnectUrl(
-            CanonicalizeUrl(url), GURL(), motivation, kConnectionsNeeded);
+        PreconnectUrl(CanonicalizeUrl(url), GURL(), motivation,
+                      kConnectionsNeeded,
+                      kAllowCredentialsOnPreconnectByDefault);
         return;  // Skip pre-resolution, since we'll open a connection.
       }
     } else {
       consecutive_omnibox_preconnect_count_ = 0;
     }
   }
 
   // Fall through and consider pre-resolution.
 
   // Omnibox tends to call in pairs (just a few milliseconds apart), and we
@@ skipping 18 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_ || !preconnect_enabled_ ||
       !url.is_valid() || !url.has_host())
     return;
   if (!CanPreresolveAndPreconnect())
     return;
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
-  PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies,
-                motivation, kConnectionsNeeded);
+  PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies, motivation,
+                kConnectionsNeeded, kAllowCredentialsOnPreconnectByDefault);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
 UrlList Predictor::GetPredictedUrlListAtStartup(
     PrefService* user_prefs,
     PrefService* local_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   UrlList urls;
   // Recall list of URLs we learned about during last session.
   // This may catch secondary hostnames, pulled in by the homepages.  It will
@@ skipping 513 matching lines @@
   // a frequent occurrence on Android.
   TrimReferrersNow();
   SerializeReferrers(referral_list);
 
   completion->Signal();
 }
 
 void Predictor::PreconnectUrl(const GURL& url,
                               const GURL& first_party_for_cookies,
                               UrlInfo::ResolutionMotivation motivation,
-                              int count) {
+                              int count,
+                              bool allow_credentials) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    PreconnectUrlOnIOThread(url, first_party_for_cookies, motivation, count);
+    PreconnectUrlOnIOThread(url, first_party_for_cookies, motivation, count,
+                            allow_credentials);
   } else {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&Predictor::PreconnectUrlOnIOThread,
-                   base::Unretained(this), url, first_party_for_cookies,
-                   motivation, count));
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&Predictor::PreconnectUrlOnIOThread, base::Unretained(this),
+                   url, first_party_for_cookies, motivation, count,
+                   allow_credentials));
   }
 }
 
 void Predictor::PreconnectUrlOnIOThread(
     const GURL& original_url,
     const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
-    int count) {
+    int count,
+    bool allow_credentials) {
   // Skip the HSTS redirect.
   GURL url = GetHSTSRedirectOnIOThread(original_url);
 
   if (observer_) {
     observer_->OnPreconnectUrl(
         url, first_party_for_cookies, motivation, count);
   }
 
-  PreconnectOnIOThread(url,
-                       first_party_for_cookies,
-                       motivation,
-                       count,
-                       url_request_context_getter_.get());
+  PreconnectOnIOThread(url, first_party_for_cookies, motivation, count,
+                       url_request_context_getter_.get(), allow_credentials);
 }
 
 void Predictor::PredictFrameSubresources(const GURL& url,
                                          const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
     return;
   if (!CanPreresolveAndPreconnect())
     return;
@@ skipping 47 matching lines @@
   Referrers::iterator it = referrers_.find(url);
   if (referrers_.end() == it) {
     // Only when we don't know anything about this url, make 2 connections
     // available.  We could do this completely via learning (by prepopulating
     // the referrer_ list with this expected value), but it would swell the
     // size of the list with all the "Leaf" nodes in the tree (nodes that don't
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
     if (preconnect_enabled_) {
       PreconnectUrlOnIOThread(url, first_party_for_cookies,
-                              UrlInfo::SELF_REFERAL_MOTIVATED, 2);
+                              UrlInfo::SELF_REFERAL_MOTIVATED, 2,
+                              kAllowCredentialsOnPreconnectByDefault);
     }
     return;
   }
 
   Referrer* referrer = &(it->second);
   referrer->IncrementUseCount();
   const UrlInfo::ResolutionMotivation motivation =
       UrlInfo::LEARNED_REFERAL_MOTIVATED;
   for (Referrer::iterator future_url = referrer->begin();
        future_url != referrer->end(); ++future_url) {
     SubresourceValue evalution(TOO_NEW);
     double connection_expectation = future_url->second.subresource_use_rate();
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.PreconnectSubresourceExpectation",
                                 static_cast<int>(connection_expectation * 100),
                                 10, 5000, 50);
     future_url->second.ReferrerWasObserved();
     if (preconnect_enabled_ &&
         connection_expectation > kPreconnectWorthyExpectedValue) {
       evalution = PRECONNECTION;
       future_url->second.IncrementPreconnectionCount();
       int count = static_cast<int>(std::ceil(connection_expectation));
       if (url.host() == future_url->first.host())
         ++count;
       PreconnectUrlOnIOThread(future_url->first, first_party_for_cookies,
-                              motivation, count);
+                              motivation, count,
+                              kAllowCredentialsOnPreconnectByDefault);
     } else if (connection_expectation > kDNSPreresolutionWorthyExpectedValue) {
       evalution = PRERESOLUTION;
       future_url->second.preresolution_increment();
       UrlInfo* queued_info = AppendToResolutionQueue(future_url->first,
                                                      motivation);
       if (queued_info)
         queued_info->SetReferringHostname(url);
     }
     UMA_HISTOGRAM_ENUMERATION("Net.PreconnectSubresourceEval", evalution,
                               SUBRESOURCE_VALUE_MAX);
@@ skipping 338 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net