Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/net/predictor_unittest.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 <time.h>
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 
@@ skipping 246 matching lines @@
 
   testing_master.Shutdown();
 }
 
 //------------------------------------------------------------------------------
 // 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 const ListValue* FindSerializationMotivation(
+static const base::ListValue* FindSerializationMotivation(
     const GURL& motivation,
-    const ListValue* referral_list) {
+    const base::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::kPredictorReferrerVersion, format_version);
-  const ListValue* motivation_list(NULL);
+  const base::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;
 }
 
-static ListValue* FindSerializationMotivation(const GURL& motivation,
-                                              ListValue* referral_list) {
-  return const_cast<ListValue*>(FindSerializationMotivation(
-      motivation, static_cast<const ListValue*>(referral_list)));
+static base::ListValue* FindSerializationMotivation(
+    const GURL& motivation,
+    base::ListValue* referral_list) {
+  return const_cast<base::ListValue*>(FindSerializationMotivation(
+      motivation, static_cast<const base::ListValue*>(referral_list)));
 }
 
 // Create a new empty serialization list.
-static ListValue* NewEmptySerializationList() {
+static base::ListValue* NewEmptySerializationList() {
   base::ListValue* list = new base::ListValue;
   list->Append(
       new base::FundamentalValue(Predictor::kPredictorReferrerVersion));
   return list;
 }
 
 // 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,
                                 double use_rate,
-                                ListValue* referral_list ) {
+                                base::ListValue* referral_list) {
   // Find the motivation if it is already used.
-  ListValue* motivation_list = FindSerializationMotivation(motivation,
+  base::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()));
+    motivation_list = new base::ListValue;
+    motivation_list->Append(new base::StringValue(motivation.spec()));
     // Provide empty subresource list.
-    motivation_list->Append(new ListValue());
+    motivation_list->Append(new base::ListValue());
 
     // ...and make it part of the serialized referral_list.
     referral_list->Append(motivation_list);
   }
 
-  ListValue* subresource_list(NULL);
+  base::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 base::StringValue(subresource.spec()));
   subresource_list->Append(new base::FundamentalValue(use_rate));
 }
 
 // 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 use_rate arguments.
 static bool GetDataFromSerialization(const GURL& motivation,
                                      const GURL& subresource,
-                                     const ListValue& referral_list,
+                                     const base::ListValue& referral_list,
                                      double* use_rate) {
-  const ListValue* motivation_list =
+  const base::ListValue* motivation_list =
       FindSerializationMotivation(motivation, &referral_list);
   if (!motivation_list)
     return false;
-  const ListValue* subresource_list;
+  const base::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->GetDouble(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) {
   Predictor predictor(true);
   predictor.SetHostResolver(host_resolver_.get());
 
-  scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
+  scoped_ptr<base::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));
 
   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) {
   Predictor predictor(true);
   predictor.SetHostResolver(host_resolver_.get());
   const GURL motivation_url("http://www.google.com:91");
   const GURL subresource_url("http://icons.google.com:90");
   const double kUseRate = 23.4;
-  scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
+  scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(motivation_url, subresource_url,
       kUseRate, referral_list.get());
 
   predictor.DeserializeReferrers(*referral_list.get());
 
-  ListValue recovered_referral_list;
+  base::ListValue recovered_referral_list;
   predictor.SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   double rate;
   EXPECT_TRUE(GetDataFromSerialization(
       motivation_url, subresource_url, recovered_referral_list, &rate));
   EXPECT_EQ(rate, kUseRate);
 
   predictor.Shutdown();
 }
 
 // Check that GetHtmlReferrerLists() doesn't crash when given duplicated
 // domains for referring URL, and that it sorts the results in the
 // correct order.
 TEST_F(PredictorTest, GetHtmlReferrerLists) {
   Predictor predictor(true);
   predictor.SetHostResolver(host_resolver_.get());
   const double kUseRate = 23.4;
-  scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
+  scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(
       GURL("http://d.google.com/x1"),
       GURL("http://foo.com/"),
       kUseRate, referral_list.get());
 
   // Duplicated hostname (d.google.com). This should not cause any crashes
   // (i.e. crbug.com/116345)
   AddToSerializedList(
       GURL("http://d.google.com/x2"),
@@ skipping 70 matching lines @@
 TEST_F(PredictorTest, ReferrerSerializationTrimTest) {
   Predictor predictor(true);
   predictor.SetHostResolver(host_resolver_.get());
   GURL motivation_url("http://www.google.com:110");
 
   GURL icon_subresource_url("http://icons.google.com:111");
   const double kRateIcon = 16.0 * Predictor::kDiscardableExpectedValue;
   GURL img_subresource_url("http://img.google.com:118");
   const double kRateImg = 8.0 * Predictor::kDiscardableExpectedValue;
 
-  scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
+  scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
       motivation_url, icon_subresource_url, kRateIcon, referral_list.get());
   AddToSerializedList(
       motivation_url, img_subresource_url, kRateImg, referral_list.get());
 
   predictor.DeserializeReferrers(*referral_list.get());
 
-  ListValue recovered_referral_list;
+  base::ListValue recovered_referral_list;
   predictor.SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   double rate;
   EXPECT_TRUE(GetDataFromSerialization(
       motivation_url, icon_subresource_url, recovered_referral_list,
       &rate));
   EXPECT_SIMILAR(rate, kRateIcon);
 
   EXPECT_TRUE(GetDataFromSerialization(
       motivation_url, img_subresource_url, recovered_referral_list, &rate));
@@ skipping 153 matching lines @@
 
   // Https works fine.
   GURL long_https("https://host:999/path?query=value");
   EXPECT_EQ(Predictor::CanonicalizeUrl(long_https),
             long_https.GetWithEmptyPath());
 }
 
 TEST_F(PredictorTest, DiscardPredictorResults) {
   Predictor predictor(true);
   predictor.SetHostResolver(host_resolver_.get());
-  ListValue referral_list;
+  base::ListValue referral_list;
   predictor.SerializeReferrers(&referral_list);
   EXPECT_EQ(1U, referral_list.GetSize());
 
   GURL host_1("http://test_1");
   GURL host_2("http://test_2");
   predictor.LearnFromNavigation(host_1, host_2);
 
   predictor.SerializeReferrers(&referral_list);
   EXPECT_EQ(2U, referral_list.GetSize());
 
@@ skipping 99 matching lines @@
 
   EXPECT_EQ(advisor->would_proxy_count_, 0);
   EXPECT_EQ(advisor->advise_count_, 1);
 
   testing_master.Shutdown();
 }
 
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 }  // namespace chrome_browser_net