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

chrome/browser/history/web_history_service.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/history/web_history_service.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 188 matching lines @@
   // The callback to execute when the query is complete.
   CompletionCallback callback_;
 
   // True if the request was started and has not yet completed, otherwise false.
   bool is_pending_;
 };
 
 // Extracts a JSON-encoded HTTP response into a DictionaryValue.
 // If |request|'s HTTP response code indicates failure, or if the response
 // body is not JSON, a null pointer is returned.
-scoped_ptr<DictionaryValue> ReadResponse(RequestImpl* request) {
-  scoped_ptr<DictionaryValue> result;
+scoped_ptr<base::DictionaryValue> ReadResponse(RequestImpl* request) {
+  scoped_ptr<base::DictionaryValue> result;
   if (request->response_code() == net::HTTP_OK) {
-    Value* value = base::JSONReader::Read(request->response_body());
+    base::Value* value = base::JSONReader::Read(request->response_body());
     if (value && value->IsType(base::Value::TYPE_DICTIONARY))
-      result.reset(static_cast<DictionaryValue*>(value));
+      result.reset(static_cast<base::DictionaryValue*>(value));
     else
       DLOG(WARNING) << "Non-JSON response received from history server.";
   }
   return result.Pass();
 }
 
 // Converts a time into a string for use as a parameter in a request to the
 // history server.
 std::string ServerTimeString(base::Time time) {
   if (time < base::Time::UnixEpoch()) {
@@ skipping 37 matching lines @@
 
   if (!version_info.empty())
     url = net::AppendQueryParameter(url, "kvi", version_info);
 
   return url;
 }
 
 // Creates a DictionaryValue to hold the parameters for a deletion.
 // Ownership is passed to the caller.
 // |url| may be empty, indicating a time-range deletion.
-DictionaryValue* CreateDeletion(
+base::DictionaryValue* CreateDeletion(
     const std::string& min_time,
     const std::string& max_time,
     const GURL& url) {
-  DictionaryValue* deletion = new DictionaryValue;
+  base::DictionaryValue* deletion = new base::DictionaryValue;
   deletion->SetString("type", "CHROME_HISTORY");
   if (url.is_valid())
     deletion->SetString("url", url.spec());
   deletion->SetString("min_timestamp_usec", min_time);
   deletion->SetString("max_timestamp_usec", max_time);
   return deletion;
 }
 
 }  // namespace
 
@@ skipping 22 matching lines @@
   GURL url = GetQueryUrl(text_query, options, server_version_info_);
   scoped_ptr<RequestImpl> request(
       new RequestImpl(profile_, url, completion_callback));
   request->Start();
   return request.PassAs<Request>();
 }
 
 scoped_ptr<WebHistoryService::Request> WebHistoryService::ExpireHistory(
     const std::vector<ExpireHistoryArgs>& expire_list,
     const ExpireWebHistoryCallback& callback) {
-  DictionaryValue delete_request;
-  scoped_ptr<ListValue> deletions(new ListValue);
+  base::DictionaryValue delete_request;
+  scoped_ptr<base::ListValue> deletions(new base::ListValue);
   base::Time now = base::Time::Now();
 
   for (std::vector<ExpireHistoryArgs>::const_iterator it = expire_list.begin();
        it != expire_list.end(); ++it) {
     // Convert the times to server timestamps.
     std::string min_timestamp = ServerTimeString(it->begin_time);
     // TODO(dubroy): Use sane time (crbug.com/146090) here when it's available.
     base::Time end_time = it->end_time;
     if (end_time.is_null() || end_time > now)
       end_time = now;
@@ skipping 42 matching lines @@
   expire_list.back().begin_time = begin_time;
   expire_list.back().end_time = end_time;
   return ExpireHistory(expire_list, callback);
 }
 
 // static
 void WebHistoryService::QueryHistoryCompletionCallback(
     const WebHistoryService::QueryWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
-  scoped_ptr<DictionaryValue> response_value;
+  scoped_ptr<base::DictionaryValue> response_value;
   if (success)
     response_value = ReadResponse(static_cast<RequestImpl*>(request));
   callback.Run(request, response_value.get());
 }
 
 void WebHistoryService::ExpireHistoryCompletionCallback(
     const WebHistoryService::ExpireWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
-  scoped_ptr<DictionaryValue> response_value;
+  scoped_ptr<base::DictionaryValue> response_value;
   if (success) {
     response_value = ReadResponse(static_cast<RequestImpl*>(request));
     if (response_value)
       response_value->GetString("version_info", &server_version_info_);
   }
   callback.Run(request, response_value.get() && success);
 }
 
 }  // namespace history