Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/declarative_webrequest/webrequest_action.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_action.h"
 
 #include <limits>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 const char kEmptyDocumentUrl[] = "data:text/html,";
 
 #define INPUT_FORMAT_VALIDATE(test) do { \
     if (!(test)) { \
       *bad_message = true; \
       return scoped_refptr<const WebRequestAction>(NULL); \
     } \
   } while (0)
 
 scoped_ptr<helpers::RequestCookie> ParseRequestCookie(
-    const DictionaryValue* dict) {
+    const base::DictionaryValue* dict) {
   scoped_ptr<helpers::RequestCookie> result(new helpers::RequestCookie);
   std::string tmp;
   if (dict->GetString(keys::kNameKey, &tmp))
     result->name.reset(new std::string(tmp));
   if (dict->GetString(keys::kValueKey, &tmp))
     result->value.reset(new std::string(tmp));
   return result.Pass();
 }
 
-void ParseResponseCookieImpl(const DictionaryValue* dict,
+void ParseResponseCookieImpl(const base::DictionaryValue* dict,
                              helpers::ResponseCookie* cookie) {
   std::string string_tmp;
   int int_tmp = 0;
   bool bool_tmp = false;
   if (dict->GetString(keys::kNameKey, &string_tmp))
     cookie->name.reset(new std::string(string_tmp));
   if (dict->GetString(keys::kValueKey, &string_tmp))
     cookie->value.reset(new std::string(string_tmp));
   if (dict->GetString(keys::kExpiresKey, &string_tmp))
     cookie->expires.reset(new std::string(string_tmp));
   if (dict->GetInteger(keys::kMaxAgeKey, &int_tmp))
     cookie->max_age.reset(new int(int_tmp));
   if (dict->GetString(keys::kDomainKey, &string_tmp))
     cookie->domain.reset(new std::string(string_tmp));
   if (dict->GetString(keys::kPathKey, &string_tmp))
     cookie->path.reset(new std::string(string_tmp));
   if (dict->GetBoolean(keys::kSecureKey, &bool_tmp))
     cookie->secure.reset(new bool(bool_tmp));
   if (dict->GetBoolean(keys::kHttpOnlyKey, &bool_tmp))
     cookie->http_only.reset(new bool(bool_tmp));
 }
 
 scoped_ptr<helpers::ResponseCookie> ParseResponseCookie(
-    const DictionaryValue* dict) {
+    const base::DictionaryValue* dict) {
   scoped_ptr<helpers::ResponseCookie> result(new helpers::ResponseCookie);
   ParseResponseCookieImpl(dict, result.get());
   return result.Pass();
 }
 
 scoped_ptr<helpers::FilterResponseCookie> ParseFilterResponseCookie(
-    const DictionaryValue* dict) {
+    const base::DictionaryValue* dict) {
   scoped_ptr<helpers::FilterResponseCookie> result(
       new helpers::FilterResponseCookie);
   ParseResponseCookieImpl(dict, result.get());
 
   int int_tmp = 0;
   bool bool_tmp = false;
   if (dict->GetInteger(keys::kAgeUpperBoundKey, &int_tmp))
     result->age_upper_bound.reset(new int(int_tmp));
   if (dict->GetInteger(keys::kAgeLowerBoundKey, &int_tmp))
     result->age_lower_bound.reset(new int(int_tmp));
@@ skipping 158 matching lines @@
   else if (instance_type == keys::kEditRequestCookieType)
     modification->type = helpers::EDIT;
   else if (instance_type == keys::kRemoveRequestCookieType)
     modification->type = helpers::REMOVE;
   else
     INPUT_FORMAT_VALIDATE(false);
 
   // Get filter.
   if (modification->type == helpers::EDIT ||
       modification->type == helpers::REMOVE) {
-    const DictionaryValue* filter = NULL;
+    const base::DictionaryValue* filter = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter));
     modification->filter = ParseRequestCookie(filter);
   }
 
   // Get new value.
   if (modification->type == helpers::ADD) {
-    const DictionaryValue* value = NULL;
+    const base::DictionaryValue* value = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value));
     modification->modification = ParseRequestCookie(value);
   } else if (modification->type == helpers::EDIT) {
-    const DictionaryValue* value = NULL;
+    const base::DictionaryValue* value = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value));
     modification->modification = ParseRequestCookie(value);
   }
 
   return scoped_refptr<const WebRequestAction>(
       new WebRequestRequestCookieAction(modification));
 }
 
 scoped_refptr<const WebRequestAction> CreateResponseCookieAction(
     const std::string& instance_type,
@@ skipping 14 matching lines @@
   else if (instance_type == keys::kEditResponseCookieType)
     modification->type = helpers::EDIT;
   else if (instance_type == keys::kRemoveResponseCookieType)
     modification->type = helpers::REMOVE;
   else
     INPUT_FORMAT_VALIDATE(false);
 
   // Get filter.
   if (modification->type == helpers::EDIT ||
       modification->type == helpers::REMOVE) {
-    const DictionaryValue* filter = NULL;
+    const base::DictionaryValue* filter = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter));
     modification->filter = ParseFilterResponseCookie(filter);
   }
 
   // Get new value.
   if (modification->type == helpers::ADD) {
-    const DictionaryValue* value = NULL;
+    const base::DictionaryValue* value = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value));
     modification->modification = ParseResponseCookie(value);
   } else if (modification->type == helpers::EDIT) {
-    const DictionaryValue* value = NULL;
+    const base::DictionaryValue* value = NULL;
     INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value));
     modification->modification = ParseResponseCookie(value);
   }
 
   return scoped_refptr<const WebRequestAction>(
       new WebRequestResponseCookieAction(modification));
 }
 
 scoped_refptr<const WebRequestAction> CreateSendMessageToExtensionAction(
     const std::string& name,
@@ skipping 775 matching lines @@
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->messages_to_extension.insert(message_);
   return result;
 }
 
 }  // namespace extensions