1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This class helps to remember what domains may be needed to be resolved when a 6 // navigation takes place to a given URL. This information is gathered when a 7 // navigation to a subresource identifies a referring URL. 8 // When future navigations take place to known referrer sites, then we 9 // speculatively either pre-warm a TCP/IP conneciton, or at a minimum, resolve 10 // the host name via DNS. 11 12 // All access to this class is performed via the Predictor class, which only 13 // operates on the IO thread. 14 15 #ifndef CHROME_BROWSER_NET_REFERRER_H_ 16 #define CHROME_BROWSER_NET_REFERRER_H_ 17 18 #include <map> 19 20 #include "base/basictypes.h" 21 #include "base/time/time.h" 22 #include "net/base/host_port_pair.h" 23 #include "url/gurl.h" 24 25 namespace base { 26 class Value; 27 } 28 29 namespace chrome_browser_net { 30 31 //------------------------------------------------------------------------------ 32 // For each hostname in a Referrer, we have a ReferrerValue. It indicates 33 // exactly how much value (re: latency reduction, or connection use) has 34 // resulted from having this entry. 35 class ReferrerValue { 36 public: 37 ReferrerValue(); 38 39 // Used during deserialization. 40 void SetSubresourceUseRate(double rate) { subresource_use_rate_ = rate; } 41 42 base::Time birth_time() const { return birth_time_; } 43 44 // Record the fact that we navigated to the associated subresource URL. This 45 // will increase the value of the expected subresource_use_rate_ 46 void SubresourceIsNeeded(); 47 48 // Record the fact that the referrer of this subresource was observed. This 49 // will diminish the expected subresource_use_rate_ (and will only be 50 // counteracted later if we really needed this subresource as a consequence 51 // of our associated referrer.) 52 void ReferrerWasObserved(); 53 54 int64 navigation_count() const { return navigation_count_; } 55 double subresource_use_rate() const { return subresource_use_rate_; } 56 57 int64 preconnection_count() const { return preconnection_count_; } 58 void IncrementPreconnectionCount() { ++preconnection_count_; } 59 60 int64 preresolution_count() const { return preresolution_count_; } 61 void preresolution_increment() { ++preresolution_count_; } 62 63 // Reduce the subresource_use_rate_ by the supplied factor, and return true 64 // if the result is still greater than the given threshold. 65 bool Trim(double reduce_rate, double threshold); 66 67 private: 68 const base::Time birth_time_; 69 70 // The number of times this item was navigated to with the fixed referrer. 71 int64 navigation_count_; 72 73 // The number of times this item was preconnected as a consequence of its 74 // referrer. 75 int64 preconnection_count_; 76 77 // The number of times this item was pre-resolved (via DNS) as a consequence 78 // of its referrer. 79 int64 preresolution_count_; 80 81 // A smoothed estimate of the expected number of connections that will be made 82 // to this subresource. 83 double subresource_use_rate_; 84 }; 85 86 //------------------------------------------------------------------------------ 87 // A list of domain names to pre-resolve. The names are the keys to this map, 88 // and the values indicate the amount of benefit derived from having each name 89 // around. 90 typedef std::map<GURL, ReferrerValue> SubresourceMap; 91 92 //------------------------------------------------------------------------------ 93 // There is one Referrer instance for each hostname that has acted as an HTTP 94 // referer (note mispelling is intentional) for a hostname that was otherwise 95 // unexpectedly navgated towards ("unexpected" in the sense that the hostname 96 // was probably needed as a subresource of a page, and was not otherwise 97 // predictable until the content with the reference arrived). Most typically, 98 // an outer page was a page fetched by the user, and this instance lists names 99 // in SubresourceMap which are subresources and that were needed to complete the 100 // rendering of the outer page. 101 class Referrer : public SubresourceMap { 102 public: 103 Referrer(); 104 void IncrementUseCount() { ++use_count_; } 105 int64 use_count() const { return use_count_; } 106 107 // Add the indicated url to the list that are resolved via DNS when the user 108 // navigates to this referrer. Note that if the list is long, an entry may be 109 // discarded to make room for this insertion. 110 void SuggestHost(const GURL& url); 111 112 // Trim the Referrer, by first diminishing (scaling down) the subresource 113 // use expectation for each ReferredValue. 114 // Returns true if expected use rate is greater than the threshold. 115 bool Trim(double reduce_rate, double threshold); 116 117 // Provide methods for persisting, and restoring contents into a Value class. 118 base::Value* Serialize() const; 119 void Deserialize(const base::Value& referrers); 120 121 private: 122 // Helper function for pruning list. Metric for usefulness is "large accrued 123 // value," in the form of latency_ savings associated with a host name. We 124 // also give credit for a name being newly added, by scalling latency per 125 // lifetime (time since birth). For instance, when two names have accrued 126 // the same latency_ savings, the older one is less valuable as it didn't 127 // accrue savings as quickly. 128 void DeleteLeastUseful(); 129 130 // The number of times this referer had its subresources scanned for possible 131 // preconnection or DNS preresolution. 132 int64 use_count_; 133 134 // We put these into a std::map<>, so we need copy constructors. 135 // DISALLOW_COPY_AND_ASSIGN(Referrer); 136 // TODO(jar): Consider optimization to use pointers to these instances, and 137 // avoid deep copies during re-alloc of the containing map. 138 }; 139 140 } // namespace chrome_browser_net 141 142 #endif // CHROME_BROWSER_NET_REFERRER_H_ 143
