summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--base/values.h4
-rw-r--r--chrome/browser/browser_main.cc1
-rw-r--r--chrome/browser/browser_shutdown.cc6
-rw-r--r--chrome/browser/net/dns_global.cc32
-rw-r--r--chrome/browser/net/dns_global.h5
-rw-r--r--chrome/browser/net/dns_master.cc46
-rw-r--r--chrome/browser/net/dns_master.h19
-rw-r--r--chrome/browser/net/dns_master_unittest.cc213
-rw-r--r--chrome/browser/net/referrer.cc63
-rw-r--r--chrome/browser/net/referrer.h17
-rw-r--r--chrome/common/pref_names.cc6
-rw-r--r--chrome/common/pref_names.h1
-rw-r--r--chrome/common/temp_scaffolding_stubs.cc4
13 files changed, 400 insertions, 17 deletions
diff --git a/base/values.h b/base/values.h
index 19a1cb9..cad1311 100644
--- a/base/values.h
+++ b/base/values.h
@@ -260,14 +260,14 @@ class DictionaryValue : public Value {
// It can't be used to modify the dictionary.
class key_iterator
: private std::iterator<std::input_iterator_tag, const std::wstring> {
- public:
+ public:
key_iterator(ValueMap::const_iterator itr) { itr_ = itr; }
key_iterator operator++() { ++itr_; return *this; }
const std::wstring& operator*() { return itr_->first; }
bool operator!=(const key_iterator& other) { return itr_ != other.itr_; }
bool operator==(const key_iterator& other) { return itr_ == other.itr_; }
- private:
+ private:
ValueMap::const_iterator itr_;
};
diff --git a/chrome/browser/browser_main.cc b/chrome/browser/browser_main.cc
index cc7acd17..d7dd579 100644
--- a/chrome/browser/browser_main.cc
+++ b/chrome/browser/browser_main.cc
@@ -446,6 +446,7 @@ int BrowserMain(const MainFunctionParams& parameters) {
// Initialize the DNS prefetch system
chrome_browser_net::DnsPrefetcherInit dns_prefetch_init(user_prefs);
chrome_browser_net::DnsPrefetchHostNamesAtStartup(user_prefs, local_state);
+ chrome_browser_net::RestoreSubresourceReferrers(local_state);
// Init common control sex.
INITCOMMONCONTROLSEX config;
diff --git a/chrome/browser/browser_shutdown.cc b/chrome/browser/browser_shutdown.cc
index d3d1b98..ef12384 100644
--- a/chrome/browser/browser_shutdown.cc
+++ b/chrome/browser/browser_shutdown.cc
@@ -114,6 +114,12 @@ void Shutdown() {
PrefService* prefs = g_browser_process->local_state();
chrome_browser_net::SaveHostNamesForNextStartup(prefs);
+ // TODO(jar): Trimming should be done more regularly, such as every 48 hours
+ // of physical time, or perhaps after 48 hours of running (excluding time
+ // between sessions possibly).
+ // For now, we'll just trim at shutdown.
+ chrome_browser_net::TrimSubresourceReferrers();
+ chrome_browser_net::SaveSubresourceReferrers(prefs);
MetricsService* metrics = g_browser_process->metrics_service();
if (metrics) {
diff --git a/chrome/browser/net/dns_global.cc b/chrome/browser/net/dns_global.cc
index b34de8a..67e4265 100644
--- a/chrome/browser/net/dns_global.cc
+++ b/chrome/browser/net/dns_global.cc
@@ -60,6 +60,7 @@ void OnTheRecord(bool enable) {
void RegisterPrefs(PrefService* local_state) {
local_state->RegisterListPref(prefs::kDnsStartupPrefetchList);
+ local_state->RegisterListPref(prefs::kDnsHostReferralList);
}
void RegisterUserPrefs(PrefService* user_prefs) {
@@ -73,8 +74,7 @@ static DnsMaster* dns_master;
// This API is only used in the browser process.
// It is called from an IPC message originating in the renderer. It currently
// includes both Page-Scan, and Link-Hover prefetching.
-// TODO(jar): Separate out link-hover prefetching, and histogram results
-// separately.
+// TODO(jar): Separate out link-hover prefetching, and page-scan results.
void DnsPrefetchList(const NameList& hostnames) {
DnsPrefetchMotivatedList(hostnames, DnsHostInfo::PAGE_SCAN_MOTIVATED);
}
@@ -221,7 +221,7 @@ void PrefetchObserver::OnFinishResolutionWithStatus(bool was_resolved,
return;
// TODO(jar): Don't add host to our list if it is a non-linked lookup, and
// instead rely on Referrers to pull this in automatically with the enclosing
- // page load.
+ // page load (once we start to persist elements of our referrer tree).
StartupListAppend(navigation_info);
}
@@ -466,6 +466,32 @@ void DnsPrefetchHostNamesAtStartup(PrefService* user_prefs,
DnsHostInfo::STARTUP_LIST_MOTIVATED);
}
+//------------------------------------------------------------------------------
+// Functions to persist and restore host references, that are used to direct DNS
+// prefetch of names (probably) used in subresources when the major resource is
+// navigated towards.
+
+void SaveSubresourceReferrers(PrefService* local_state) {
+ if (NULL == dns_master)
+ return;
+ ListValue* referral_list =
+ local_state->GetMutableList(prefs::kDnsHostReferralList);
+ dns_master->SerializeReferrers(referral_list);
+}
+
+void RestoreSubresourceReferrers(PrefService* local_state) {
+ if (NULL == dns_master)
+ return;
+ ListValue* referral_list =
+ local_state->GetMutableList(prefs::kDnsHostReferralList);
+ dns_master->DeserializeReferrers(*referral_list);
+}
+
+void TrimSubresourceReferrers() {
+ if (NULL == dns_master)
+ return;
+ dns_master->TrimReferrers();
+}
} // namespace chrome_browser_net
diff --git a/chrome/browser/net/dns_global.h b/chrome/browser/net/dns_global.h
index 7bf441d..2ba0e70 100644
--- a/chrome/browser/net/dns_global.h
+++ b/chrome/browser/net/dns_global.h
@@ -41,6 +41,11 @@ void SaveHostNamesForNextStartup(PrefService* local_state);
void DnsPrefetchHostNamesAtStartup(PrefService* user_prefs,
PrefService* local_state);
+// Functions to save and restore sub-resource references.
+void SaveSubresourceReferrers(PrefService* local_state);
+void RestoreSubresourceReferrers(PrefService* local_state);
+void TrimSubresourceReferrers();
+
//------------------------------------------------------------------------------
// Helper class to handle global init and shutdown.
class DnsPrefetcherInit {
diff --git a/chrome/browser/net/dns_master.cc b/chrome/browser/net/dns_master.cc
index 4d477b0..34efe37 100644
--- a/chrome/browser/net/dns_master.cc
+++ b/chrome/browser/net/dns_master.cc
@@ -537,5 +537,51 @@ void DnsMaster::DiscardAllResults() {
}
}
+void DnsMaster::TrimReferrers() {
+ std::vector<std::string> hosts;
+ AutoLock auto_lock(lock_);
+ for (Referrers::const_iterator it = referrers_.begin();
+ it != referrers_.end(); ++it)
+ hosts.push_back(it->first);
+ for (size_t i = 0; i < hosts.size(); ++i)
+ if (!referrers_[hosts[i]].Trim())
+ referrers_.erase(hosts[i]);
+}
+
+void DnsMaster::SerializeReferrers(ListValue* referral_list) {
+ referral_list->Clear();
+ AutoLock auto_lock(lock_);
+ for (Referrers::const_iterator it = referrers_.begin();
+ it != referrers_.end(); ++it) {
+ // Serialize the list of subresource names.
+ Value* subresource_list(it->second.Serialize());
+
+ // Create a list for each referer.
+ ListValue* motivating_host(new ListValue);
+ motivating_host->Append(new StringValue(it->first));
+ motivating_host->Append(subresource_list);
+
+ referral_list->Append(motivating_host);
+ }
+}
+
+void DnsMaster::DeserializeReferrers(const ListValue& referral_list) {
+ AutoLock auto_lock(lock_);
+ for (size_t i = 0; i < referral_list.GetSize(); ++i) {
+ ListValue* motivating_host;
+ if (!referral_list.GetList(i, &motivating_host))
+ continue;
+ std::string motivating_referrer;
+ if (!motivating_host->GetString(0, &motivating_referrer))
+ continue;
+ Value* subresource_list;
+ if (!motivating_host->Get(1, &subresource_list))
+ continue;
+ if (motivating_referrer.empty())
+ continue;
+ referrers_[motivating_referrer].Deserialize(*subresource_list);
+ }
+}
+
} // namespace chrome_browser_net
diff --git a/chrome/browser/net/dns_master.h b/chrome/browser/net/dns_master.h
index f406b32..72116cd 100644
--- a/chrome/browser/net/dns_master.h
+++ b/chrome/browser/net/dns_master.h
@@ -23,6 +23,7 @@
#include "base/condition_variable.h"
#include "base/scoped_ptr.h"
+#include "base/values.h"
#include "chrome/browser/net/dns_host_info.h"
#include "chrome/browser/net/referrer.h"
#include "chrome/common/net/dns.h"
@@ -118,6 +119,22 @@ class DnsMaster {
return running_slave_count_;
}
+ // Discard any referrer for which all the suggested host names are currently
+ // annotated with no user latency reduction. Also scale down (diminish) the
+ // total benefit of those that did help, so that their reported contribution
+ // wll go done by a factor of 2 each time we trim (moving the referrer closer
+ // to being discarded at a future Trim).
+ void TrimReferrers();
+
+ // Construct a ListValue object that contains all the data in the referrers_
+ // so that it can be persisted in a pref.
+ void SerializeReferrers(ListValue* referral_list);
+
+ // Process a ListValue that contains all the data from a previous reference
+ // list, as constructed by SerializeReferrers(), and add all the identified
+ // values into the current referrer list.
+ void DeserializeReferrers(const ListValue& referral_list);
+
//----------------------------------------------------------------------------
// Methods below this line should only be called by slave processes.
@@ -184,7 +201,7 @@ class DnsMaster {
HANDLE thread_handles_[kSlaveCountMax];
DnsSlave* slaves_[kSlaveCountMax];
#endif
-
+
// shutdown_ is set to tell the slaves to terminate.
bool shutdown_;
diff --git a/chrome/browser/net/dns_master_unittest.cc b/chrome/browser/net/dns_master_unittest.cc
index 650a8ff..b9eb34f 100644
--- a/chrome/browser/net/dns_master_unittest.cc
+++ b/chrome/browser/net/dns_master_unittest.cc
@@ -146,13 +146,28 @@ TEST(DnsMasterTest, OsCachesLookupsTest) {
SetupNetworkInfrastructure();
net::EnsureWinsockInit();
- for (int i = 0; i < 5; i++) {
- std::string badname;
- badname = GetNonexistantDomain();
- TimeDelta duration = BlockingDnsLookup(badname);
- TimeDelta cached_duration = BlockingDnsLookup(badname);
- EXPECT_TRUE(duration > cached_duration);
- }
+ // To avoid flaky nature of a timed test, we'll run an outer loop until we get
+ // 90% of the inner loop tests to pass.
+ // Originally we just did one set of 5 tests and demand 100%, but that proved
+ // flakey. With this set-looping approach, we always pass in one set (when it
+ // used to pass). If we don't get that first set to pass, then we allow an
+ // average of one failure per two major sets. If the test runs too long, then
+ // there probably is a real problem, and the test harness will terminate us
+ // with a failure.
+ int pass_count(0);
+ int fail_count(0);
+ do {
+ for (int i = 0; i < 5; i++) {
+ std::string badname;
+ badname = GetNonexistantDomain();
+ TimeDelta duration = BlockingDnsLookup(badname);
+ TimeDelta cached_duration = BlockingDnsLookup(badname);
+ if (duration > cached_duration)
+ pass_count++;
+ else
+ fail_count++;
+ }
+ } while (fail_count * 9 > pass_count);
}
TEST(DnsMasterTest, StartupShutdownTest) {
@@ -428,5 +443,189 @@ TEST(DnsMasterTest, DISABLED_MultiThreadedSpeedupTest) {
EXPECT_TRUE(testing_master.ShutdownSlaves());
}
+//------------------------------------------------------------------------------
+// Functions to help synthesize and test serializations of subresource referrer
+// lists.
+
+// Return a motivation_list if we can find one for the given motivating_host (or
+// NULL if a match is not found).
+static ListValue* FindSerializationMotivation(const std::string& motivation,
+ const ListValue& referral_list) {
+ ListValue* motivation_list(NULL);
+ for (size_t i = 0; i < referral_list.GetSize(); ++i) {
+ referral_list.GetList(i, &motivation_list);
+ std::string existing_motivation;
+ EXPECT_TRUE(motivation_list->GetString(i, &existing_motivation));
+ if (existing_motivation == motivation)
+ break;
+ motivation_list = NULL;
+ }
+ return motivation_list;
+}
+
+// Add a motivating_host and a subresource_host to a serialized list, using
+// this given latency. This is a helper function for quickly building these
+// lists.
+static void AddToSerializedList(const std::string& motivation,
+ const std::string& subresource, int latency,
+ ListValue* referral_list ) {
+ // Find the motivation if it is already used.
+ ListValue* motivation_list = FindSerializationMotivation(motivation,
+ *referral_list);
+ if (!motivation_list) {
+ // This is the first mention of this motivation, so build a list.
+ motivation_list = new ListValue;
+ motivation_list->Append(new StringValue(motivation));
+ // Provide empty subresource list.
+ motivation_list->Append(new ListValue());
+
+ // ...and make it part of the serialized referral_list.
+ referral_list->Append(motivation_list);
+ }
+
+ ListValue* subresource_list(NULL);
+ EXPECT_TRUE(motivation_list->GetList(1, &subresource_list));
+
+ // We won't bother to check for the subresource being there already. Worst
+ // case, during deserialization, the latency value we supply plus the
+ // existing value(s) will be added to the referrer.
+ subresource_list->Append(new StringValue(subresource));
+ subresource_list->Append(new FundamentalValue(latency));
+}
+
+static const int kLatencyNotFound = -1;
+
+// For a given motivation_hostname, and subresource_hostname, find what latency
+// is currently listed. This assume a well formed serialization, which has
+// at most one such entry for any pair of names. If no such pair is found, then
+// return kLatencyNotFound.
+int GetLatencyFromSerialization(const std::string& motivation,
+ const std::string& subresource,
+ const ListValue& referral_list) {
+ ListValue* motivation_list = FindSerializationMotivation(motivation,
+ referral_list);
+ if (!motivation_list)
+ return kLatencyNotFound;
+ ListValue* subresource_list;
+ EXPECT_TRUE(motivation_list->GetList(1, &subresource_list));
+ for (size_t i = 0; i < subresource_list->GetSize(); ++i) {
+ std::string subresource_name;
+ EXPECT_TRUE(subresource_list->GetString(i, &subresource_name));
+ if (subresource_name == subresource) {
+ int latency;
+ EXPECT_TRUE(subresource_list->GetInteger(i + 1, &latency));
+ return latency;
+ }
+ ++i; // Skip latency value.
+ }
+ return kLatencyNotFound;
+}
+
+//------------------------------------------------------------------------------
+
+// Make sure nil referral lists really have no entries, and no latency listed.
+TEST(DnsMasterTest, ReferrerSerializationNilTest) {
+ DnsMaster master(TimeDelta::FromSeconds(30));
+ ListValue referral_list;
+ master.SerializeReferrers(&referral_list);
+ EXPECT_EQ(0, referral_list.GetSize());
+ EXPECT_EQ(kLatencyNotFound, GetLatencyFromSerialization("a.com", "b.com",
+ referral_list));
+}
+
+// Make sure that when a serialization list includes a value, that it can be
+// deserialized into the database, and can be extracted back out via
+// serialization without being changed.
+TEST(DnsMasterTest, ReferrerSerializationSingleReferrerTest) {
+ DnsMaster master(TimeDelta::FromSeconds(30));
+ std::string motivation_hostname = "www.google.com";
+ std::string subresource_hostname = "icons.google.com";
+ const int kLatency = 3;
+ ListValue referral_list;
+
+ AddToSerializedList(motivation_hostname, subresource_hostname, kLatency,
+ &referral_list);
+
+ master.DeserializeReferrers(referral_list);
+
+ ListValue recovered_referral_list;
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(1, recovered_referral_list.GetSize());
+ EXPECT_EQ(kLatency, GetLatencyFromSerialization(motivation_hostname,
+ subresource_hostname,
+ recovered_referral_list));
+}
+
+// Make sure the Trim() functionality works as expected.
+TEST(DnsMasterTest, ReferrerSerializationTrimTest) {
+ DnsMaster master(TimeDelta::FromSeconds(30));
+ std::string motivation_hostname = "www.google.com";
+ std::string icon_subresource_hostname = "icons.google.com";
+ std::string img_subresource_hostname = "img.google.com";
+ ListValue referral_list;
+
+ AddToSerializedList(motivation_hostname, icon_subresource_hostname, 10,
+ &referral_list);
+ AddToSerializedList(motivation_hostname, img_subresource_hostname, 3,
+ &referral_list);
+
+ master.DeserializeReferrers(referral_list);
+
+ ListValue recovered_referral_list;
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(1, recovered_referral_list.GetSize());
+ EXPECT_EQ(10, GetLatencyFromSerialization(motivation_hostname,
+ icon_subresource_hostname,
+ recovered_referral_list));
+ EXPECT_EQ(3, GetLatencyFromSerialization(motivation_hostname,
+ img_subresource_hostname,
+ recovered_referral_list));
+
+ // Each time we Trim, the latency figures should reduce by a factor of two,
+ // until they both are 0, an then a trim will delete the whole entry.
+ master.TrimReferrers();
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(1, recovered_referral_list.GetSize());
+ EXPECT_EQ(5, GetLatencyFromSerialization(motivation_hostname,
+ icon_subresource_hostname,
+ recovered_referral_list));
+ EXPECT_EQ(1, GetLatencyFromSerialization(motivation_hostname,
+ img_subresource_hostname,
+ recovered_referral_list));
+
+ master.TrimReferrers();
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(1, recovered_referral_list.GetSize());
+ EXPECT_EQ(2, GetLatencyFromSerialization(motivation_hostname,
+ icon_subresource_hostname,
+ recovered_referral_list));
+ EXPECT_EQ(0, GetLatencyFromSerialization(motivation_hostname,
+ img_subresource_hostname,
+ recovered_referral_list));
+
+ master.TrimReferrers();
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(1, recovered_referral_list.GetSize());
+ EXPECT_EQ(1, GetLatencyFromSerialization(motivation_hostname,
+ icon_subresource_hostname,
+ recovered_referral_list));
+ EXPECT_EQ(0, GetLatencyFromSerialization(motivation_hostname,
+ img_subresource_hostname,
+ recovered_referral_list));
+
+ master.TrimReferrers();
+ master.SerializeReferrers(&recovered_referral_list);
+ EXPECT_EQ(0, recovered_referral_list.GetSize());
+ EXPECT_EQ(kLatencyNotFound,
+ GetLatencyFromSerialization(motivation_hostname,
+ icon_subresource_hostname,
+ recovered_referral_list));
+ EXPECT_EQ(kLatencyNotFound,
+ GetLatencyFromSerialization(motivation_hostname,
+ img_subresource_hostname,
+ recovered_referral_list));
+}
+
+
} // namespace
diff --git a/chrome/browser/net/referrer.cc b/chrome/browser/net/referrer.cc
index 464c990..283faf6 100644
--- a/chrome/browser/net/referrer.cc
+++ b/chrome/browser/net/referrer.cc
@@ -34,7 +34,7 @@ void Referrer::DeleteLeastUseful() {
int64 least_useful_lifetime = 0; // Duration in milliseconds.
const base::Time kNow(base::Time::Now()); // Avoid multiple calls.
- for (HostNameMap::iterator it = this->begin(); it != this->end(); ++it) {
+ for (HostNameMap::iterator it = begin(); it != end(); ++it) {
int64 lifetime = (kNow - it->second.birth_time()).InMilliseconds();
int64 latency = it->second.latency().InMilliseconds();
if (!least_useful_name.empty()) {
@@ -66,10 +66,67 @@ void Referrer::DeleteLeastUseful() {
void Referrer::AccrueValue(const base::TimeDelta& delta,
const std::string host) {
- HostNameMap::iterator it = this->find(host);
+ HostNameMap::iterator it = find(host);
// Be careful that we weren't evicted from this referrer in DeleteLeastUseful.
- if (it != this->end())
+ if (it != end())
it->second.AccrueValue(delta);
}
+bool Referrer::Trim() {
+ bool has_some_latency_left = false;
+ for (HostNameMap::iterator it = begin(); it != end(); ++it)
+ if (it->second.Trim())
+ has_some_latency_left = true;
+ return has_some_latency_left;
+}
+
+bool ReferrerValue::Trim() {
+ int64 latency_ms = latency_.InMilliseconds() / 2;
+ latency_ = base::TimeDelta::FromMilliseconds(latency_ms);
+ return latency_ms > 0;
+}
+
+
+void Referrer::Deserialize(const Value& value) {
+ if (value.GetType() != Value::TYPE_LIST)
+ return;
+ const ListValue* subresource_list(static_cast<const ListValue*>(&value));
+ for (size_t index = 0; index + 1 < subresource_list->GetSize(); index += 2) {
+ std::string host;
+ if (!subresource_list->GetString(index, &host))
+ return;
+ int latency_ms;
+ if (!subresource_list->GetInteger(index + 1, &latency_ms))
+ return;
+ base::TimeDelta latency = base::TimeDelta::FromMilliseconds(latency_ms);
+ // TODO(jar): We could be more direct, and change birth date or similar to
+ // show that this is a resurrected value we're adding in. I'm not yet sure
+ // of how best to optimize the learning and pruning (Trim) algorithm at this
+ // level, so for now, we just suggest subresources, which leaves them all
+ // with the same birth date (typically start of process).
+ SuggestHost(host);
+ AccrueValue(latency, host);
+ }
+}
+
+Value* Referrer::Serialize() const {
+ ListValue* subresource_list(new ListValue);
+ for (const_iterator it = begin(); it != end(); ++it) {
+ StringValue* host(new StringValue(it->first));
+ int latency_integer = static_cast<int>(it->second.latency().
+ InMilliseconds());
+ // Watch out for overflow in the above static_cast! Check to see if we went
+ // negative, and just use a "big" value. The value seems unimportant once
+ // we get to such high latencies. Probable cause of high latency is a bug
+ // in other code, so also do a DCHECK.
+ DCHECK(latency_integer >= 0);
+ if (latency_integer < 0)
+ latency_integer = INT_MAX;
+ FundamentalValue* latency(new FundamentalValue(latency_integer));
+ subresource_list->Append(host);
+ subresource_list->Append(latency);
+ }
+ return subresource_list;
+}
+
} // namespace chrome_browser_net
diff --git a/chrome/browser/net/referrer.h b/chrome/browser/net/referrer.h
index d3fb12e..69c0278 100644
--- a/chrome/browser/net/referrer.h
+++ b/chrome/browser/net/referrer.h
@@ -19,6 +19,7 @@
#include "base/basictypes.h"
#include "base/time.h"
+#include "base/values.h"
#include "googleurl/src/gurl.h"
namespace chrome_browser_net {
@@ -34,6 +35,11 @@ class ReferrerValue {
base::TimeDelta latency() const { return latency_; }
base::Time birth_time() const { return birth_time_; }
void AccrueValue(const base::TimeDelta& delta) { latency_ += delta; }
+
+ // Reduce the latency figure by a factor of 2, and return true if any latency
+ // remains.
+ bool Trim();
+
private:
base::TimeDelta latency_; // Accumulated latency savings.
const base::Time birth_time_;
@@ -49,7 +55,7 @@ typedef std::map<std::string, ReferrerValue> HostNameMap;
// There is one Referrer instance for each hostname that has acted as an HTTP
// referer (note mispelling is intentional) for a hostname that was otherwise
// unexpectedly navgated towards ("unexpected" in the sense that the hostname
-// was probably needad as a subresource of a page, and was not otherwise
+// was probably needed as a subresource of a page, and was not otherwise
// predictable until the content with the reference arrived). Most typically,
// an outer page was a page fetched by the user, and this instance lists names
// in HostNameMap which are subresources and that were needed to complete the
@@ -65,6 +71,15 @@ class Referrer : public HostNameMap {
// Value is expressed as positive latency of amount delta.
void AccrueValue(const base::TimeDelta& delta, const std::string host);
+ // Trim the Referrer, by first diminishing (scaling down) the latency for each
+ // ReferredValue.
+ // Returns true if there are any referring names with some latency left.
+ bool Trim();
+
+ // Provide methods for persisting, and restoring contents into a Value class.
+ Value* Serialize() const;
+ void Deserialize(const Value& referrers);
+
private:
// Helper function for pruning list. Metric for usefulness is "large accrued
// value," in the form of latency_ savings associated with a host name. We
diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index 8c8dc76..b10f4f0 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -188,6 +188,12 @@ const wchar_t kDnsPrefetchingEnabled[] = L"dns_prefetching.enabled";
// next startup, based on what was actually needed during this startup.
const wchar_t kDnsStartupPrefetchList[] = L"StartupDNSPrefetchList";
+// A list of host names used to fetch web pages, and their commonly used
+// sub-resource hostnames (and expected latency benefits from pre-resolving such
+// sub-resource hostnames).
+// This list is adaptively grown and pruned.
+extern const wchar_t kDnsHostReferralList[] = L"HostReferralList";
+
// The disabled messages in IPC logging.
const wchar_t kIpcDisabledMessages[] = L"ipc_log_disabled_messages";
diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index 501b3e0..f1f47a6 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -62,6 +62,7 @@ extern const wchar_t kPromptForDownload[];
extern const wchar_t kAlternateErrorPagesEnabled[];
extern const wchar_t kDnsPrefetchingEnabled[];
extern const wchar_t kDnsStartupPrefetchList[];
+extern const wchar_t kDnsHostReferralList[];
extern const wchar_t kIpcDisabledMessages[];
extern const wchar_t kShowHomeButton[];
extern const wchar_t kRecentlySelectedEncoding[];
diff --git a/chrome/common/temp_scaffolding_stubs.cc b/chrome/common/temp_scaffolding_stubs.cc
index 9ba6d3e..a5f2cd4 100644
--- a/chrome/common/temp_scaffolding_stubs.cc
+++ b/chrome/common/temp_scaffolding_stubs.cc
@@ -340,6 +340,10 @@ void DnsPrefetchList(const std::vector<std::string>& hostnames) {
void SaveHostNamesForNextStartup(PrefService* local_state) { NOTIMPLEMENTED(); }
+void TrimSubresourceReferrers() { NOTIMPLEMENTED(); }
+
+void SaveSubresourceReferrers(PrefService* local_state) { NOTIMPLEMENTED(); }
+
} // namespace chrome_browser_net
//--------------------------------------------------------------------------
generated by cgit v1.1 at 2025-01-18 23:17:35 +0000