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

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute_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 "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
@@ skipping 18 matching lines @@
 namespace extensions {
 
 namespace keys = declarative_webrequest_constants;
 
 TEST(WebRequestConditionAttributeTest, CreateConditionAttribute) {
   // Necessary for TestURLRequest.
   base::MessageLoop message_loop(base::MessageLoop::TYPE_IO);
 
   std::string error;
   scoped_refptr<const WebRequestConditionAttribute> result;
-  StringValue string_value("main_frame");
-  ListValue resource_types;
+  base::StringValue string_value("main_frame");
+  base::ListValue resource_types;
   resource_types.Append(new base::StringValue("main_frame"));
 
   // Test wrong condition name passed.
   error.clear();
   result = WebRequestConditionAttribute::Create(
       kUnknownConditionName, &resource_types, &error);
   EXPECT_FALSE(error.empty());
   EXPECT_FALSE(result.get());
 
   // Test wrong data type passed
@@ skipping 18 matching lines @@
   EXPECT_EQ(WebRequestConditionAttribute::CONDITION_RESOURCE_TYPE,
             result->GetType());
   EXPECT_EQ(std::string(keys::kResourceTypeKey), result->GetName());
 }
 
 TEST(WebRequestConditionAttributeTest, ResourceType) {
   // Necessary for TestURLRequest.
   base::MessageLoop message_loop(base::MessageLoop::TYPE_IO);
 
   std::string error;
-  ListValue resource_types;
+  base::ListValue resource_types;
   // The 'sub_frame' value is chosen arbitrarily, so as the corresponding
   // ResourceType::Type is not 0, the default value.
   resource_types.Append(new base::StringValue("sub_frame"));
 
   scoped_refptr<const WebRequestConditionAttribute> attribute =
       WebRequestConditionAttribute::Create(
           keys::kResourceTypeKey, &resource_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute.get());
   EXPECT_EQ(std::string(keys::kResourceTypeKey), attribute->GetName());
@@ skipping 30 matching lines @@
 
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
   net::TestURLRequest url_request(test_server.GetURL("files/headers.html"),
                                   net::DEFAULT_PRIORITY,
                                   &delegate,
                                   &context);
   url_request.Start();
   base::MessageLoop::current()->Run();
 
-  ListValue content_types;
+  base::ListValue content_types;
   content_types.Append(new base::StringValue("text/plain"));
   scoped_refptr<const WebRequestConditionAttribute> attribute_include =
       WebRequestConditionAttribute::Create(
           keys::kContentTypeKey, &content_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_include.get());
   EXPECT_FALSE(attribute_include->IsFulfilled(
       WebRequestData(&url_request, ON_BEFORE_REQUEST,
                      url_request.response_headers())));
   EXPECT_TRUE(attribute_include->IsFulfilled(
@@ skipping 110 matching lines @@
 
   // Check that exactly all active stages are considered in this test.
   unsigned int covered_stages = 0;
   for (size_t i = 0; i < arraysize(active_stages); ++i)
     covered_stages |= active_stages[i].first;
   EXPECT_EQ(kActiveStages, covered_stages);
 
   std::string error;
 
   // Create an attribute with an empty set of applicable stages.
-  ListValue empty_list;
+  base::ListValue empty_list;
   scoped_refptr<const WebRequestConditionAttribute> empty_attribute =
       WebRequestConditionAttribute::Create(keys::kStagesKey,
                                            &empty_list,
                                            &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(empty_attribute.get());
   EXPECT_EQ(std::string(keys::kStagesKey), empty_attribute->GetName());
 
   // Create an attribute with all possible applicable stages.
-  ListValue all_stages;
+  base::ListValue all_stages;
   for (size_t i = 0; i < arraysize(active_stages); ++i)
     all_stages.AppendString(active_stages[i].second);
   scoped_refptr<const WebRequestConditionAttribute> attribute_with_all =
       WebRequestConditionAttribute::Create(keys::kStagesKey,
                                            &all_stages,
                                            &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_with_all.get());
   EXPECT_EQ(std::string(keys::kStagesKey), attribute_with_all->GetName());
 
   // Create one attribute for each single stage, to be applicable in that stage.
   std::vector<scoped_refptr<const WebRequestConditionAttribute> >
       one_stage_attributes;
 
   for (size_t i = 0; i < arraysize(active_stages); ++i) {
-    ListValue single_stage_list;
+    base::ListValue single_stage_list;
     single_stage_list.AppendString(active_stages[i].second);
     one_stage_attributes.push_back(
         WebRequestConditionAttribute::Create(keys::kStagesKey,
                                              &single_stage_list,
                                              &error));
     EXPECT_EQ("", error);
     ASSERT_TRUE(one_stage_attributes.back().get() != NULL);
   }
 
   const GURL url_empty;
@@ skipping 37 matching lines @@
     out->push_back(std::vector<const std::string*>());
     for (size_t j = next; j < next + sizes[i]; ++j) {
       out->back().push_back(&(array[j]));
     }
     next += sizes[i];
   }
 }
 
 // Builds a DictionaryValue from an array of the form {name1, value1, name2,
 // value2, ...}. Values for the same key are grouped in a ListValue.
-scoped_ptr<DictionaryValue> GetDictionaryFromArray(
+scoped_ptr<base::DictionaryValue> GetDictionaryFromArray(
     const std::vector<const std::string*>& array) {
   const size_t length = array.size();
   CHECK(length % 2 == 0);
 
-  scoped_ptr<DictionaryValue> dictionary(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   for (size_t i = 0; i < length; i += 2) {
     const std::string* name = array[i];
     const std::string* value = array[i+1];
     if (dictionary->HasKey(*name)) {
-      Value* entry = NULL;
-      scoped_ptr<Value> entry_owned;
-      ListValue* list = NULL;
+      base::Value* entry = NULL;
+      scoped_ptr<base::Value> entry_owned;
+      base::ListValue* list = NULL;
       if (!dictionary->GetWithoutPathExpansion(*name, &entry))
-        return scoped_ptr<DictionaryValue>();
+        return scoped_ptr<base::DictionaryValue>();
       switch (entry->GetType()) {
-        case Value::TYPE_STRING:  // Replace the present string with a list.
-          list = new ListValue;
+        case base::Value::TYPE_STRING:
+          // Replace the present string with a list.
+          list = new base::ListValue;
           // Ignoring return value, we already verified the entry is there.
           dictionary->RemoveWithoutPathExpansion(*name, &entry_owned);
           list->Append(entry_owned.release());
           list->Append(new base::StringValue(*value));
           dictionary->SetWithoutPathExpansion(*name, list);
           break;
-        case Value::TYPE_LIST:  // Just append to the list.
+        case base::Value::TYPE_LIST:  // Just append to the list.
           CHECK(entry->GetAsList(&list));
           list->Append(new base::StringValue(*value));
           break;
         default:
           NOTREACHED();  // We never put other Values here.
-          return scoped_ptr<DictionaryValue>();
+          return scoped_ptr<base::DictionaryValue>();
       }
     } else {
       dictionary->SetString(*name, *value);
     }
   }
   return dictionary.Pass();
 }
 
 // Returns whether the response headers from |url_request| satisfy the match
 // criteria given in |tests|. For at least one |i| all tests from |tests[i]|
 // must pass. If |positive_test| is true, the dictionary is interpreted as the
 // containsHeaders property of a RequestMatcher, otherwise as
 // doesNotContainHeaders.
 void MatchAndCheck(const std::vector< std::vector<const std::string*> >& tests,
                    const std::string& key,
                    RequestStage stage,
                    net::URLRequest* url_request,
                    bool* result) {
-  ListValue contains_headers;
+  base::ListValue contains_headers;
   for (size_t i = 0; i < tests.size(); ++i) {
-    scoped_ptr<DictionaryValue> temp(GetDictionaryFromArray(tests[i]));
+    scoped_ptr<base::DictionaryValue> temp(GetDictionaryFromArray(tests[i]));
     ASSERT_TRUE(temp.get());
     contains_headers.Append(temp.release());
   }
 
   std::string error;
   scoped_refptr<const WebRequestConditionAttribute> attribute =
       WebRequestConditionAttribute::Create(key, &contains_headers, &error);
   ASSERT_EQ("", error);
   ASSERT_TRUE(attribute.get());
   EXPECT_EQ(key, attribute->GetName());
@@ skipping 266 matching lines @@
     keys::kValueEqualsKey, "valueB"
   };
   const size_t kExistingSize[] = { arraysize(kExisting) };
   GetArrayAsVector(kExisting, kExistingSize, 1u, &tests);
   MatchAndCheck(
       tests, keys::kExcludeResponseHeadersKey, stage, &url_request, &result);
   EXPECT_FALSE(result);
 }
 
 }  // namespace extensions