Support both preconnection, and pre-resolution for subresources...

chrome/browser/net/predictor_unittest.cc

 // Copyright (c) 2006-2010 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 <time.h>
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 
@@ skipping 97 matching lines @@
 //------------------------------------------------------------------------------
 
 TEST_F(PredictorTest, StartupShutdownTest) {
   scoped_refptr<Predictor> testing_master = new Predictor(host_resolver_,
       default_max_queueing_delay_,
       PredictorInit::kMaxPrefetchConcurrentLookups,
       false);
   testing_master->Shutdown();
 }
 
-TEST_F(PredictorTest, BenefitLookupTest) {
-  scoped_refptr<Predictor> testing_master = new Predictor(
-      host_resolver_,
-      default_max_queueing_delay_,
-      PredictorInit::kMaxPrefetchConcurrentLookups,
-      false);
-
-  GURL goog("http://www.google.com:80"),
-      goog2("http://gmail.google.com.com:80"),
-      goog3("http://mail.google.com:80"),
-      goog4("http://gmail.com:80");
-  UrlInfo goog_info, goog2_info, goog3_info, goog4_info;
-
-  // Simulate getting similar names from a network observer
-  goog_info.SetUrl(goog);
-  goog2_info.SetUrl(goog2);
-  goog3_info.SetUrl(goog3);
-  goog4_info.SetUrl(goog4);
-
-  goog_info.SetStartedState();
-  goog2_info.SetStartedState();
-  goog3_info.SetStartedState();
-  goog4_info.SetStartedState();
-
-  goog_info.SetFinishedState(true);
-  goog2_info.SetFinishedState(true);
-  goog3_info.SetFinishedState(true);
-  goog4_info.SetFinishedState(true);
-
-  UrlList names;
-  names.push_back(goog);
-  names.push_back(goog2);
-  names.push_back(goog3);
-  names.push_back(goog4);
-
-  testing_master->ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
-
-  WaitForResolution(testing_master, names);
-
-  EXPECT_TRUE(testing_master->WasFound(goog));
-  EXPECT_TRUE(testing_master->WasFound(goog2));
-  EXPECT_TRUE(testing_master->WasFound(goog3));
-  EXPECT_TRUE(testing_master->WasFound(goog4));
-
-  // With the mock DNS, each of these should have taken some time, and hence
-  // shown a benefit (i.e., prefetch cost more than network access time).
-
-  GURL referer;  // Null host.
-
-  // Simulate actual navigation, and acrue the benefit for "helping" the DNS
-  // part of the navigation.
-  EXPECT_TRUE(testing_master->AccruePrefetchBenefits(referer, &goog_info));
-  EXPECT_TRUE(testing_master->AccruePrefetchBenefits(referer, &goog2_info));
-  EXPECT_TRUE(testing_master->AccruePrefetchBenefits(referer, &goog3_info));
-  EXPECT_TRUE(testing_master->AccruePrefetchBenefits(referer, &goog4_info));
-
-  // Benefits can ONLY be reported once (for the first navigation).
-  EXPECT_FALSE(testing_master->AccruePrefetchBenefits(referer, &goog_info));
-  EXPECT_FALSE(testing_master->AccruePrefetchBenefits(referer, &goog2_info));
-  EXPECT_FALSE(testing_master->AccruePrefetchBenefits(referer, &goog3_info));
-  EXPECT_FALSE(testing_master->AccruePrefetchBenefits(referer, &goog4_info));
-
-  testing_master->Shutdown();
-}
 
 TEST_F(PredictorTest, ShutdownWhenResolutionIsPendingTest) {
   scoped_refptr<net::WaitingHostResolverProc> resolver_proc =
       new net::WaitingHostResolverProc(NULL);
   host_resolver_->Reset(resolver_proc);
 
   scoped_refptr<Predictor> testing_master = new Predictor(host_resolver_,
       default_max_queueing_delay_,
       PredictorInit::kMaxPrefetchConcurrentLookups,
       false);
@@ skipping 128 matching lines @@
 // 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 GURL& motivation, const ListValue& referral_list) {
   CHECK_LT(0u, referral_list.GetSize());  // Room for version.
   int format_version = -1;
   CHECK(referral_list.GetInteger(0, &format_version));
-  CHECK_EQ(Predictor::DNS_REFERRER_VERSION, format_version);
+  CHECK_EQ(Predictor::PREDICTOR_REFERRER_VERSION, format_version);
   ListValue* motivation_list(NULL);
   for (size_t i = 1; i < referral_list.GetSize(); ++i) {
     referral_list.GetList(i, &motivation_list);
     std::string existing_spec;
     EXPECT_TRUE(motivation_list->GetString(0, &existing_spec));
     if (motivation == GURL(existing_spec))
       return motivation_list;
   }
   return NULL;
 }
 
 // Create a new empty serialization list.
 static ListValue* NewEmptySerializationList() {
   ListValue* list = new ListValue;
-  list->Append(new FundamentalValue(Predictor::DNS_REFERRER_VERSION));
+  list->Append(new FundamentalValue(Predictor::PREDICTOR_REFERRER_VERSION));
   return list;
 }
 
-// Add a motivating_host and a subresource_host to a serialized list, using
+// Add a motivating_url and a subresource_url to a serialized list, using
 // this given latency. This is a helper function for quickly building these
 // lists.
 static void AddToSerializedList(const GURL& motivation,
                                 const GURL& subresource,
-                                int latency,
-                                double rate,
+                                double use_rate,
                                 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.spec()));
     // 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);
   // 0 == url; 1 == subresource_list.
   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.spec()));
-  subresource_list->Append(new FundamentalValue(latency));
-  subresource_list->Append(new FundamentalValue(rate));
+  subresource_list->Append(new FundamentalValue(use_rate));
 }
 
 static const int kLatencyNotFound = -1;
 
 // For a given motivation, and subresource, 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 false.
-// Data is written into rate and latency arguments.
+// Data is written into use_rate arguments.
 static bool GetDataFromSerialization(const GURL& motivation,
                                      const GURL& subresource,
                                      const ListValue& referral_list,
-                                     double* rate,
-                                     int* latency) {
+                                     double* use_rate) {
   ListValue* motivation_list = FindSerializationMotivation(motivation,
                                                            referral_list);
   if (!motivation_list)
     return false;
   ListValue* subresource_list;
   EXPECT_TRUE(motivation_list->GetList(1, &subresource_list));
   for (size_t i = 0; i < subresource_list->GetSize();) {
     std::string url_spec;
     EXPECT_TRUE(subresource_list->GetString(i++, &url_spec));
-    EXPECT_TRUE(subresource_list->GetInteger(i++, latency));
-    EXPECT_TRUE(subresource_list->GetReal(i++, rate));
+    EXPECT_TRUE(subresource_list->GetReal(i++, use_rate));
     if (subresource == GURL(url_spec)) {
       return true;
     }
   }
   return false;
 }
 
 //------------------------------------------------------------------------------
 
 // Make sure nil referral lists really have no entries, and no latency listed.
 TEST_F(PredictorTest, ReferrerSerializationNilTest) {
   scoped_refptr<Predictor> predictor = new Predictor(host_resolver_,
       default_max_queueing_delay_,
       PredictorInit::kMaxPrefetchConcurrentLookups,
       false);
   scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
   predictor->SerializeReferrers(referral_list.get());
   EXPECT_EQ(1U, referral_list->GetSize());
   EXPECT_FALSE(GetDataFromSerialization(
     GURL("http://a.com:79"), GURL("http://b.com:78"),
-      *referral_list.get(), NULL, NULL));
+      *referral_list.get(), NULL));
 
   predictor->Shutdown();
 }
 
 // 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_F(PredictorTest, ReferrerSerializationSingleReferrerTest) {
   scoped_refptr<Predictor> predictor = new Predictor(host_resolver_,
       default_max_queueing_delay_,
       PredictorInit::kMaxPrefetchConcurrentLookups,
       false);
   const GURL motivation_url("http://www.google.com:91");
   const GURL subresource_url("http://icons.google.com:90");
-  const int kLatency = 3;
-  const double kRate = 23.4;
+  const double kUseRate = 23.4;
   scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(motivation_url, subresource_url,
-      kLatency, kRate, referral_list.get());
+      kUseRate, referral_list.get());
 
   predictor->DeserializeReferrers(*referral_list.get());
 
   ListValue recovered_referral_list;
   predictor->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
-  int latency;
   double rate;
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, subresource_url, recovered_referral_list, &rate,
-      &latency));
-  EXPECT_EQ(rate, kRate);
-  EXPECT_EQ(latency, kLatency);
+      motivation_url, subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kUseRate);
 
   predictor->Shutdown();
 }
 
 // Make sure the Trim() functionality works as expected.
 TEST_F(PredictorTest, ReferrerSerializationTrimTest) {
   scoped_refptr<Predictor> predictor = new Predictor(host_resolver_,
       default_max_queueing_delay_,
       PredictorInit::kMaxPrefetchConcurrentLookups,
       false);
   GURL motivation_url("http://www.google.com:110");
 
   GURL icon_subresource_url("http://icons.google.com:111");
-  const int kLatencyIcon = 10;
-  const double kRateIcon = 0.;  // User low rate, so latency will dominate.
+  const double kRateIcon = 16.0 * Predictor::kPersistWorthyExpectedValue;
   GURL img_subresource_url("http://img.google.com:118");
-  const int kLatencyImg = 3;
-  const double kRateImg = 0.;
+  const double kRateImg = 8.0 * Predictor::kPersistWorthyExpectedValue;
 
   scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
-      motivation_url, icon_subresource_url,
-      kLatencyIcon, kRateIcon, referral_list.get());
+      motivation_url, icon_subresource_url, kRateIcon, referral_list.get());
   AddToSerializedList(
-      motivation_url, img_subresource_url,
-      kLatencyImg, kRateImg, referral_list.get());
+      motivation_url, img_subresource_url, kRateImg, referral_list.get());
 
   predictor->DeserializeReferrers(*referral_list.get());
 
   ListValue recovered_referral_list;
   predictor->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
-  int latency;
   double rate;
   EXPECT_TRUE(GetDataFromSerialization(
       motivation_url, icon_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyIcon);
+      &rate));
   EXPECT_EQ(rate, kRateIcon);
 
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, img_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyImg);
+      motivation_url, img_subresource_url, recovered_referral_list, &rate));
   EXPECT_EQ(rate, kRateImg);
 
-  // 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.
+  // Each time we Trim, the user_rate figures should reduce by a factor of two,
+  // until they both are small, an then a trim will delete the whole entry.
   predictor->TrimReferrers();
   predictor->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, icon_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyIcon / 2);
-  EXPECT_EQ(rate, kRateIcon);
+      motivation_url, icon_subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kRateIcon / 2);
 
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, img_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyImg / 2);
-  EXPECT_EQ(rate, kRateImg);
+      motivation_url, img_subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kRateImg / 2);
 
   predictor->TrimReferrers();
   predictor->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, icon_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyIcon / 4);
-  EXPECT_EQ(rate, kRateIcon);
-  // Img is down to zero, but we don't delete it yet.
+      motivation_url, icon_subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kRateIcon / 4);
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, img_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(kLatencyImg / 4, 0);
-  EXPECT_EQ(latency, kLatencyImg / 4);
-  EXPECT_EQ(rate, kRateImg);
+      motivation_url, img_subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kRateImg / 4);
 
   predictor->TrimReferrers();
   predictor->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, icon_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(latency, kLatencyIcon / 8);
-  EXPECT_EQ(rate, kRateIcon);
+      motivation_url, icon_subresource_url, recovered_referral_list, &rate));
+  EXPECT_EQ(rate, kRateIcon / 8);
 
-  // Img is down to zero, but we don't delete it yet.
-  EXPECT_TRUE(GetDataFromSerialization(
-      motivation_url, img_subresource_url, recovered_referral_list,
-      &rate, &latency));
-  EXPECT_EQ(kLatencyImg / 8, 0);
-  EXPECT_EQ(latency, kLatencyImg / 8);
-  EXPECT_EQ(rate, kRateImg);
+  // Img is below threshold, and so it gets deleted.
+  EXPECT_FALSE(GetDataFromSerialization(
+      motivation_url, img_subresource_url, recovered_referral_list, &rate));
 
   predictor->TrimReferrers();
   predictor->SerializeReferrers(&recovered_referral_list);
   // Icon is also trimmed away, so entire set gets discarded.
   EXPECT_EQ(1U, recovered_referral_list.GetSize());
   EXPECT_FALSE(GetDataFromSerialization(
-      motivation_url, icon_subresource_url, recovered_referral_list,
-      &rate, &latency));
+      motivation_url, icon_subresource_url, recovered_referral_list, &rate));
   EXPECT_FALSE(GetDataFromSerialization(
-      motivation_url, img_subresource_url, recovered_referral_list,
-      &rate, &latency));
+      motivation_url, img_subresource_url, recovered_referral_list, &rate));
 
   predictor->Shutdown();
 }
 
 
 TEST_F(PredictorTest, PriorityQueuePushPopTest) {
   Predictor::HostNameQueue queue;
 
   GURL first("http://first:80"), second("http://second:90");
 
@@ skipping 55 matching lines @@
   EXPECT_EQ(queue.Pop(), low2);
   EXPECT_EQ(queue.Pop(), low3);
   EXPECT_EQ(queue.Pop(), low4);
   EXPECT_EQ(queue.Pop(), low5);
   EXPECT_EQ(queue.Pop(), low4);
 
   EXPECT_TRUE(queue.IsEmpty());
 }
 
 }  // namespace chrome_browser_net