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

chrome/browser/drive/fake_drive_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/drive/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 108 matching lines @@
                                      end_position),
                  base::Passed(&entry)));
 }
 
 void EntryActionCallbackAdapter(
     const EntryActionCallback& callback,
     GDataErrorCode error, scoped_ptr<ResourceEntry> resource_entry) {
   callback.Run(error);
 }
 
-void ClearPropatiesForPermanentDelete(DictionaryValue* entry) {
-  scoped_ptr<DictionaryValue> new_entry(new DictionaryValue);
+void ClearPropatiesForPermanentDelete(base::DictionaryValue* entry) {
+  scoped_ptr<base::DictionaryValue> new_entry(new base::DictionaryValue);
   const char* kPreservedProperties[] = {
     "docs$removed", "docs$changestamp", "gd$resourceId", "id", "updated"
   };
 
   for (size_t i = 0; i < arraysize(kPreservedProperties); ++i) {
     const char* key = kPreservedProperties[i];
-    scoped_ptr<Value> value;
+    scoped_ptr<base::Value> value;
     if (entry->Remove(key, &value))
       new_entry->Set(key, value.release());
   }
 
   entry->Swap(new_entry.get());
 }
 
 }  // namespace
 
 struct FakeDriveService::UploadSession {
@@ skipping 44 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FakeDriveService::~FakeDriveService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 bool FakeDriveService::LoadResourceListForWapi(
     const std::string& relative_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  scoped_ptr<Value> raw_value = test_util::LoadJSONFile(relative_path);
+  scoped_ptr<base::Value> raw_value = test_util::LoadJSONFile(relative_path);
   base::DictionaryValue* as_dict = NULL;
   scoped_ptr<base::Value> feed;
   base::DictionaryValue* feed_as_dict = NULL;
 
   // Extract the "feed" from the raw value and take the ownership.
   // Note that Remove() transfers the ownership to |feed|.
   if (raw_value->GetAsDictionary(&as_dict) &&
       as_dict->Remove("feed", &feed) &&
       feed->GetAsDictionary(&feed_as_dict)) {
     ignore_result(feed.release());
@@ skipping 386 matching lines @@
         }
 
         std::string entry_etag;
         entry->GetString("gd$etag", &entry_etag);
         if (!etag.empty() && entry_etag != etag) {
           base::MessageLoop::current()->PostTask(
               FROM_HERE, base::Bind(callback, HTTP_PRECONDITION));
           return CancelCallback();
         }
 
-        entry->Set("docs$removed", new DictionaryValue);
+        entry->Set("docs$removed", new base::DictionaryValue);
         AddNewChangestamp(entry);
         ClearPropatiesForPermanentDelete(entry);
         base::MessageLoop::current()->PostTask(
             FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
         return CancelCallback();
       }
     }
   }
 
   base::MessageLoop::current()->PostTask(
@@ skipping 19 matching lines @@
     for (size_t i = 0; i < entries->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
       std::string current_resource_id;
       if (entries->GetDictionary(i, &entry) &&
           entry->GetString("gd$resourceId.$t", &current_resource_id) &&
           resource_id == current_resource_id) {
         GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
         if (entry->HasKey("gd$deleted") || entry->HasKey("docs$removed")) {
           error = HTTP_NOT_FOUND;
         } else {
-          entry->Set("gd$deleted", new DictionaryValue);
+          entry->Set("gd$deleted", new base::DictionaryValue);
           AddNewChangestamp(entry);
           error = HTTP_SUCCESS;
         }
         base::MessageLoop::current()->PostTask(
             FROM_HERE, base::Bind(callback, error));
         return CancelCallback();
       }
     }
   }
 
@@ skipping 108 matching lines @@
   base::ListValue* entries = NULL;
   // Go through entries and copy the one that matches |resource_id|.
   if (resource_list_value_->GetList("entry", &entries)) {
     for (size_t i = 0; i < entries->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
       std::string current_resource_id;
       if (entries->GetDictionary(i, &entry) &&
           entry->GetString("gd$resourceId.$t", &current_resource_id) &&
           resource_id == current_resource_id) {
         // Make a copy and set the new resource ID and the new title.
-        scoped_ptr<DictionaryValue> copied_entry(entry->DeepCopy());
+        scoped_ptr<base::DictionaryValue> copied_entry(entry->DeepCopy());
         copied_entry->SetString("gd$resourceId.$t",
                                 resource_id + "_copied");
         copied_entry->SetString("title.$t", new_title);
 
         // Reset parent directory.
         base::ListValue* links = NULL;
         if (!copied_entry->GetList("link", &links)) {
           links = new base::ListValue;
           copied_entry->Set("link", links);
         }
@@ skipping 301 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
-  DictionaryValue* entry = FindEntryByResourceId(resource_id);
+  base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
 
   std::string entry_etag;
   entry->GetString("gd$etag", &entry_etag);
   if (!etag.empty() && etag != entry_etag) {
@@ skipping 87 matching lines @@
     session->uploaded_size = end_position;
     completion_callback.Run(GDATA_FILE_ERROR, scoped_ptr<ResourceEntry>());
     return CancelCallback();
   }
   session->uploaded_size = end_position;
 
   // |resource_id| is empty if the upload is for new file.
   if (session->resource_id.empty()) {
     DCHECK(!session->parent_resource_id.empty());
     DCHECK(!session->title.empty());
-    const DictionaryValue* new_entry = AddNewEntry(
+    const base::DictionaryValue* new_entry = AddNewEntry(
         session->content_type,
         content_data,
         session->parent_resource_id,
         session->title,
         false,  // shared_with_me
         "file");
     if (!new_entry) {
       completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<ResourceEntry>());
       return CancelCallback();
     }
 
     completion_callback.Run(HTTP_CREATED,
                             ResourceEntry::CreateFrom(*new_entry));
     return CancelCallback();
   }
 
-  DictionaryValue* entry = FindEntryByResourceId(session->resource_id);
+  base::DictionaryValue* entry = FindEntryByResourceId(session->resource_id);
   if (!entry) {
     completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<ResourceEntry>());
     return CancelCallback();
   }
 
   std::string entry_etag;
   entry->GetString("gd$etag", &entry_etag);
   if (entry_etag.empty() || session->etag != entry_etag) {
     completion_callback.Run(HTTP_PRECONDITION, scoped_ptr<ResourceEntry>());
     return CancelCallback();
@@ skipping 320 matching lines @@
   UpdateETag(new_entry.get());
 
   base::Time published_date =
       base::Time() + base::TimeDelta::FromMilliseconds(++published_date_seq_);
   new_entry->SetString(
       "published.$t",
       google_apis::util::FormatTimeAsString(published_date));
 
   // If there are no entries, prepare an empty entry to add.
   if (!resource_list_value_->HasKey("entry"))
-    resource_list_value_->Set("entry", new ListValue);
+    resource_list_value_->Set("entry", new base::ListValue);
 
   base::DictionaryValue* raw_new_entry = new_entry.release();
   base::ListValue* entries = NULL;
   if (resource_list_value_->GetList("entry", &entries))
     entries->Append(raw_new_entry);
 
   return raw_new_entry;
 }
 
 void FakeDriveService::GetResourceListInternal(
@@ skipping 119 matching lines @@
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, base::Passed(&resource_list)));
 }
 
 GURL FakeDriveService::GetNewUploadSessionUrl() {
   return GURL("https://upload_session_url/" +
               base::Int64ToString(next_upload_sequence_number_++));
 }
 
 }  // namespace drive