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

chrome/browser/extensions/activity_log/activity_actions.cc

 // Copyright (c) 2013 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/activity_log/activity_actions.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 57 matching lines @@
   clone->set_page_url(page_url());
   clone->set_page_title(page_title());
   clone->set_page_incognito(page_incognito());
   clone->set_arg_url(arg_url());
   clone->set_arg_incognito(arg_incognito());
   if (other())
     clone->set_other(make_scoped_ptr(other()->DeepCopy()));
   return clone;
 }
 
-void Action::set_args(scoped_ptr<ListValue> args) {
+void Action::set_args(scoped_ptr<base::ListValue> args) {
   args_.reset(args.release());
 }
 
-ListValue* Action::mutable_args() {
+base::ListValue* Action::mutable_args() {
   if (!args_.get()) {
-    args_.reset(new ListValue());
+    args_.reset(new base::ListValue());
   }
   return args_.get();
 }
 
 void Action::set_page_url(const GURL& page_url) {
   page_url_ = page_url;
 }
 
 void Action::set_arg_url(const GURL& arg_url) {
   arg_url_ = arg_url;
 }
 
-void Action::set_other(scoped_ptr<DictionaryValue> other) {
+void Action::set_other(scoped_ptr<base::DictionaryValue> other) {
   other_.reset(other.release());
 }
 
-DictionaryValue* Action::mutable_other() {
+base::DictionaryValue* Action::mutable_other() {
   if (!other_.get()) {
-    other_.reset(new DictionaryValue());
+    other_.reset(new base::DictionaryValue());
   }
   return other_.get();
 }
 
 std::string Action::SerializePageUrl() const {
   return (page_incognito() ? constants::kIncognitoUrl : "") + page_url().spec();
 }
 
 void Action::ParsePageUrl(const std::string& url) {
   set_page_incognito(StartsWithASCII(url, constants::kIncognitoUrl, true));
@@ skipping 63 matching lines @@
     result->arg_url.reset(new std::string(SerializeArgUrl()));
 
   if (other()) {
     scoped_ptr<ExtensionActivity::Other> other_field(
         new ExtensionActivity::Other);
     bool prerender;
     if (other()->GetBooleanWithoutPathExpansion(constants::kActionPrerender,
                                                 &prerender)) {
       other_field->prerender.reset(new bool(prerender));
     }
-    const DictionaryValue* web_request;
+    const base::DictionaryValue* web_request;
     if (other()->GetDictionaryWithoutPathExpansion(constants::kActionWebRequest,
                                                    &web_request)) {
       other_field->web_request.reset(new std::string(
           ActivityLogPolicy::Util::Serialize(web_request)));
     }
     std::string extra;
     if (other()->GetStringWithoutPathExpansion(constants::kActionExtra, &extra))
       other_field->extra.reset(new std::string(extra));
     int dom_verb;
     if (other()->GetIntegerWithoutPathExpansion(constants::kActionDomVerb,
@@ skipping 65 matching lines @@
   if (args_.get()) {
     result += " ARGS=" + Serialize(args_.get());
   }
   if (page_url_.is_valid()) {
     if (page_incognito_)
       result += " PAGE_URL=(incognito)" + page_url_.spec();
     else
       result += " PAGE_URL=" + page_url_.spec();
   }
   if (!page_title_.empty()) {
-    StringValue title(page_title_);
+    base::StringValue title(page_title_);
     result += " PAGE_TITLE=" + Serialize(&title);
   }
   if (arg_url_.is_valid()) {
     if (arg_incognito_)
       result += " ARG_URL=(incognito)" + arg_url_.spec();
     else
       result += " ARG_URL=" + arg_url_.spec();
   }
   if (other_.get()) {
     result += " OTHER=" + Serialize(other_.get());
@@ skipping 59 matching lines @@
     std::string rhs_other = ActivityLogPolicy::Util::Serialize(rhs->other());
     if (lhs_other != rhs_other)
       return lhs_other < rhs_other;
   }
 
   // All fields compare as equal if this point is reached.
   return false;
 }
 
 }  // namespace extensions