Update uses of Value in chromeos/, cloud_print/, components/, content/ to use the base:: namespace.

content/browser/indexed_db/indexed_db_context_impl.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 "content/browser/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 144 matching lines @@
                                    idb_directory,
                                    connection_count));
   }
   return result;
 }
 
 static bool HostNameComparator(const GURL& i, const GURL& j) {
   return i.host() < j.host();
 }
 
-ListValue* IndexedDBContextImpl::GetAllOriginsDetails() {
+base::ListValue* IndexedDBContextImpl::GetAllOriginsDetails() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   std::vector<GURL> origins = GetAllOrigins();
 
   std::sort(origins.begin(), origins.end(), HostNameComparator);
 
-  scoped_ptr<ListValue> list(new ListValue());
+  scoped_ptr<base::ListValue> list(new base::ListValue());
   for (std::vector<GURL>::const_iterator iter = origins.begin();
        iter != origins.end();
        ++iter) {
     const GURL& origin_url = *iter;
 
-    scoped_ptr<DictionaryValue> info(new DictionaryValue());
+    scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue());
     info->SetString("url", origin_url.spec());
     info->SetString("size", ui::FormatBytes(GetOriginDiskUsage(origin_url)));
     info->SetDouble("last_modified",
                     GetOriginLastModified(origin_url).ToJsTime());
     info->SetString("path", GetFilePath(origin_url).value());
     info->SetDouble("connection_count", GetConnectionCount(origin_url));
 
     // This ends up being O(n^2) since we iterate over all open databases
     // to extract just those in the origin, and we're iterating over all
     // origins in the outer loop.
 
     if (factory_) {
       std::vector<IndexedDBDatabase*> databases =
           factory_->GetOpenDatabasesForOrigin(origin_url);
       // TODO(jsbell): Sort by name?
-      scoped_ptr<ListValue> database_list(new ListValue());
+      scoped_ptr<base::ListValue> database_list(new base::ListValue());
 
       for (std::vector<IndexedDBDatabase*>::iterator it = databases.begin();
            it != databases.end();
            ++it) {
 
         const IndexedDBDatabase* db = *it;
-        scoped_ptr<DictionaryValue> db_info(new DictionaryValue());
+        scoped_ptr<base::DictionaryValue> db_info(new base::DictionaryValue());
 
         db_info->SetString("name", db->name());
         db_info->SetDouble("pending_opens", db->PendingOpenCount());
         db_info->SetDouble("pending_upgrades", db->PendingUpgradeCount());
         db_info->SetDouble("running_upgrades", db->RunningUpgradeCount());
         db_info->SetDouble("pending_deletes", db->PendingDeleteCount());
         db_info->SetDouble("connection_count",
                            db->ConnectionCount() - db->PendingUpgradeCount() -
                                db->RunningUpgradeCount());
 
-        scoped_ptr<ListValue> transaction_list(new ListValue());
+        scoped_ptr<base::ListValue> transaction_list(new base::ListValue());
         std::vector<const IndexedDBTransaction*> transactions =
             db->transaction_coordinator().GetTransactions();
         for (std::vector<const IndexedDBTransaction*>::iterator trans_it =
                  transactions.begin();
              trans_it != transactions.end();
              ++trans_it) {
 
           const IndexedDBTransaction* transaction = *trans_it;
-          scoped_ptr<DictionaryValue> transaction_info(new DictionaryValue());
+          scoped_ptr<base::DictionaryValue> transaction_info(
+              new base::DictionaryValue());
 
           const char* kModes[] = { "readonly", "readwrite", "versionchange" };
           transaction_info->SetString("mode", kModes[transaction->mode()]);
           switch (transaction->state()) {
             case IndexedDBTransaction::CREATED:
               transaction_info->SetString("status", "blocked");
               break;
             case IndexedDBTransaction::STARTED:
               if (transaction->diagnostics().tasks_scheduled > 0)
                 transaction_info->SetString("status", "running");
@@ skipping 19 matching lines @@
                   .InMillisecondsF());
           transaction_info->SetDouble(
               "runtime",
               (base::Time::Now() - transaction->diagnostics().start_time)
                   .InMillisecondsF());
           transaction_info->SetDouble(
               "tasks_scheduled", transaction->diagnostics().tasks_scheduled);
           transaction_info->SetDouble(
               "tasks_completed", transaction->diagnostics().tasks_completed);
 
-          scoped_ptr<ListValue> scope(new ListValue());
+          scoped_ptr<base::ListValue> scope(new base::ListValue());
           for (std::set<int64>::const_iterator scope_it =
                    transaction->scope().begin();
                scope_it != transaction->scope().end();
                ++scope_it) {
             IndexedDBDatabaseMetadata::ObjectStoreMap::const_iterator it =
                 db->metadata().object_stores.find(*scope_it);
             if (it != db->metadata().object_stores.end())
               scope->AppendString(it->second.name);
           }
 
@@ skipping 310 matching lines @@
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 base::TaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_;
 }
 
 }  // namespace content