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

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.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 <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 120 matching lines @@
 ~WebRequestConditionAttributeResourceType() {}
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeResourceType::Create(
     const std::string& instance_type,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(instance_type == keys::kResourceTypeKey);
-  const ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                             keys::kResourceTypeKey);
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
   }
 
   size_t number_types = value_as_list->GetSize();
 
   std::vector<ResourceType::Type> passed_types;
   passed_types.reserve(number_types);
@@ skipping 65 matching lines @@
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeContentType::Create(
       const std::string& name,
       const base::Value* value,
       std::string* error,
       bool* bad_message) {
   DCHECK(name == keys::kContentTypeKey || name == keys::kExcludeContentTypeKey);
 
-  const ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
   }
   std::vector<std::string> content_types;
-  for (ListValue::const_iterator it = value_as_list->begin();
+  for (base::ListValue::const_iterator it = value_as_list->begin();
        it != value_as_list->end(); ++it) {
     std::string content_type;
     if (!(*it)->GetAsString(&content_type)) {
       *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
       return scoped_refptr<const WebRequestConditionAttribute>(NULL);
     }
     content_types.push_back(content_type);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
@@ skipping 63 matching lines @@
   bool TestNameValue(const std::string& name, const std::string& value) const;
 
  private:
   // Represents a single string-matching test.
   class StringMatchTest {
    public:
     enum MatchType { kPrefix, kSuffix, kEquals, kContains };
 
     // |data| is the pattern to be matched in the position given by |type|.
     // Note that |data| must point to a StringValue object.
-    static scoped_ptr<StringMatchTest> Create(const Value* data,
+    static scoped_ptr<StringMatchTest> Create(const base::Value* data,
                                               MatchType type,
                                               bool case_sensitive);
     ~StringMatchTest();
 
     // Does |str| pass |this| StringMatchTest?
     bool Matches(const std::string& str) const;
 
    private:
     StringMatchTest(const std::string& data,
                     MatchType type,
@@ skipping 39 matching lines @@
 };
 
 // HeaderMatcher implementation.
 
 HeaderMatcher::~HeaderMatcher() {}
 
 // static
 scoped_ptr<const HeaderMatcher> HeaderMatcher::Create(
     const base::ListValue* tests) {
   ScopedVector<const HeaderMatchTest> header_tests;
-  for (ListValue::const_iterator it = tests->begin();
+  for (base::ListValue::const_iterator it = tests->begin();
        it != tests->end(); ++it) {
-    const DictionaryValue* tests = NULL;
+    const base::DictionaryValue* tests = NULL;
     if (!(*it)->GetAsDictionary(&tests))
       return scoped_ptr<const HeaderMatcher>();
 
     scoped_ptr<const HeaderMatchTest> header_test(
         HeaderMatchTest::Create(tests));
     if (header_test.get() == NULL)
       return scoped_ptr<const HeaderMatcher>();
     header_tests.push_back(header_test.release());
   }
 
   return scoped_ptr<const HeaderMatcher>(new HeaderMatcher(&header_tests));
 }
 
 bool HeaderMatcher::TestNameValue(const std::string& name,
                                   const std::string& value) const {
   for (size_t i = 0; i < tests_.size(); ++i) {
     if (tests_[i]->Matches(name, value))
       return true;
   }
   return false;
 }
 
 HeaderMatcher::HeaderMatcher(ScopedVector<const HeaderMatchTest>* tests)
   : tests_(tests->Pass()) {}
 
 // HeaderMatcher::StringMatchTest implementation.
 
 // static
 scoped_ptr<HeaderMatcher::StringMatchTest>
-HeaderMatcher::StringMatchTest::Create(const Value* data,
+HeaderMatcher::StringMatchTest::Create(const base::Value* data,
                                        MatchType type,
                                        bool case_sensitive) {
   std::string str;
   CHECK(data->GetAsString(&str));
   return scoped_ptr<StringMatchTest>(
       new StringMatchTest(str, type, case_sensitive));
 }
 
 HeaderMatcher::StringMatchTest::~StringMatchTest() {}
 
@@ skipping 36 matching lines @@
       value_match_(value_match->Pass()) {}
 
 HeaderMatcher::HeaderMatchTest::~HeaderMatchTest() {}
 
 // static
 scoped_ptr<const HeaderMatcher::HeaderMatchTest>
 HeaderMatcher::HeaderMatchTest::Create(const base::DictionaryValue* tests) {
   ScopedVector<const StringMatchTest> name_match;
   ScopedVector<const StringMatchTest> value_match;
 
-  for (DictionaryValue::Iterator it(*tests); !it.IsAtEnd(); it.Advance()) {
+  for (base::DictionaryValue::Iterator it(*tests);
+       !it.IsAtEnd(); it.Advance()) {
     bool is_name = false;  // Is this test for header name?
     StringMatchTest::MatchType match_type;
     if (it.key() == keys::kNamePrefixKey) {
       is_name = true;
       match_type = StringMatchTest::kPrefix;
     } else if (it.key() == keys::kNameSuffixKey) {
       is_name = true;
       match_type = StringMatchTest::kSuffix;
     } else if (it.key() == keys::kNameContainsKey) {
       is_name = true;
       match_type = StringMatchTest::kContains;
     } else if (it.key() == keys::kNameEqualsKey) {
       is_name = true;
       match_type = StringMatchTest::kEquals;
     } else if (it.key() == keys::kValuePrefixKey) {
       match_type = StringMatchTest::kPrefix;
     } else if (it.key() == keys::kValueSuffixKey) {
       match_type = StringMatchTest::kSuffix;
     } else if (it.key() == keys::kValueContainsKey) {
       match_type = StringMatchTest::kContains;
     } else if (it.key() == keys::kValueEqualsKey) {
       match_type = StringMatchTest::kEquals;
     } else {
       NOTREACHED();  // JSON schema type checking should prevent this.
       return scoped_ptr<const HeaderMatchTest>();
     }
-    const Value* content = &it.value();
+    const base::Value* content = &it.value();
 
     ScopedVector<const StringMatchTest>* tests =
         is_name ? &name_match : &value_match;
     switch (content->GetType()) {
-      case Value::TYPE_LIST: {
-        const ListValue* list = NULL;
+      case base::Value::TYPE_LIST: {
+        const base::ListValue* list = NULL;
         CHECK(content->GetAsList(&list));
-        for (ListValue::const_iterator it = list->begin();
+        for (base::ListValue::const_iterator it = list->begin();
              it != list->end(); ++it) {
           tests->push_back(
               StringMatchTest::Create(*it, match_type, !is_name).release());
         }
         break;
       }
-      case Value::TYPE_STRING: {
+      case base::Value::TYPE_STRING: {
         tests->push_back(
             StringMatchTest::Create(content, match_type, !is_name).release());
         break;
       }
       default: {
         NOTREACHED();  // JSON schema type checking should prevent this.
         return scoped_ptr<const HeaderMatchTest>();
       }
     }
   }
@@ skipping 30 matching lines @@
 
 WebRequestConditionAttributeRequestHeaders::
 ~WebRequestConditionAttributeRequestHeaders() {}
 
 namespace {
 
 scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
-  const ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_ptr<const HeaderMatcher>();
   }
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       HeaderMatcher::Create(value_as_list));
   if (header_matcher.get() == NULL)
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
   return header_matcher.Pass();
@@ skipping 218 matching lines @@
     : allowed_stages_(allowed_stages) {}
 
 WebRequestConditionAttributeStages::
 ~WebRequestConditionAttributeStages() {}
 
 namespace {
 
 // Reads strings stored in |value|, which is expected to be a ListValue, and
 // sets corresponding bits (see RequestStage) in |out_stages|. Returns true on
 // success, false otherwise.
-bool ParseListOfStages(const Value& value, int* out_stages) {
-  const ListValue* list = NULL;
+bool ParseListOfStages(const base::Value& value, int* out_stages) {
+  const base::ListValue* list = NULL;
   if (!value.GetAsList(&list))
     return false;
 
   int stages = 0;
   std::string stage_name;
-  for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
+  for (base::ListValue::const_iterator it = list->begin();
+       it != list->end(); ++it) {
     if (!((*it)->GetAsString(&stage_name)))
       return false;
     if (stage_name == keys::kOnBeforeRequestEnum) {
       stages |= ON_BEFORE_REQUEST;
     } else if (stage_name == keys::kOnBeforeSendHeadersEnum) {
       stages |= ON_BEFORE_SEND_HEADERS;
     } else if (stage_name == keys::kOnHeadersReceivedEnum) {
       stages |= ON_HEADERS_RECEIVED;
     } else if (stage_name == keys::kOnAuthRequiredEnum) {
       stages |= ON_AUTH_REQUIRED;
     } else {
       NOTREACHED();  // JSON schema checks prevent getting here.
       return false;
     }
   }
 
   *out_stages = stages;
   return true;
 }
 
 }  // namespace
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeStages::Create(const std::string& name,
-                                           const Value* value,
+                                           const base::Value* value,
                                            std::string* error,
                                            bool* bad_message) {
   DCHECK(name == keys::kStagesKey);
 
   int allowed_stages = 0;
   if (!ParseListOfStages(*value, &allowed_stages)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kStagesKey);
     return scoped_refptr<const WebRequestConditionAttribute>(NULL);
   }
@@ skipping 24 matching lines @@
 bool WebRequestConditionAttributeStages::Equals(
     const WebRequestConditionAttribute* other) const {
   if (!WebRequestConditionAttribute::Equals(other))
     return false;
   const WebRequestConditionAttributeStages* casted_other =
       static_cast<const WebRequestConditionAttributeStages*>(other);
   return allowed_stages_ == casted_other->allowed_stages_;
 }
 
 }  // namespace extensions