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

chrome/browser/metrics/metrics_log_serializer.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/metrics/metrics_log_serializer.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/md5.h"
@@ skipping 75 matching lines @@
   DCHECK(logs);
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
   const char* pref;
   if (log_type == MetricsLogBase::INITIAL_LOG)
     pref = prefs::kMetricsInitialLogs;
   else
     pref = prefs::kMetricsOngoingLogs;
 
-  const ListValue* unsent_logs = local_state->GetList(pref);
+  const base::ListValue* unsent_logs = local_state->GetList(pref);
   ReadLogsFromPrefList(*unsent_logs, logs);
 }
 
 // static
 void MetricsLogSerializer::WriteLogsToPrefList(
     const std::vector<MetricsLogManager::SerializedLog>& local_list,
     size_t list_length_limit,
     size_t byte_limit,
     base::ListValue* list) {
   // One of the limit arguments must be non-zero.
@@ skipping 17 matching lines @@
         break;
       bytes_used += log_size;
       --start;
     }
   }
   DCHECK_LT(start, local_list.size());
   if (start >= local_list.size())
     return;
 
   // Store size at the beginning of the list.
-  list->Append(Value::CreateIntegerValue(local_list.size() - start));
+  list->Append(base::Value::CreateIntegerValue(local_list.size() - start));
 
   base::MD5Context ctx;
   base::MD5Init(&ctx);
   std::string encoded_log;
   for (std::vector<MetricsLogManager::SerializedLog>::const_iterator it =
            local_list.begin() + start;
        it != local_list.end(); ++it) {
     // We encode the compressed log as Value::CreateStringValue() expects to
     // take a valid UTF8 string.
     base::Base64Encode(it->log_text(), &encoded_log);
     base::MD5Update(&ctx, encoded_log);
-    list->Append(Value::CreateStringValue(encoded_log));
+    list->Append(base::Value::CreateStringValue(encoded_log));
   }
 
   // Append hash to the end of the list.
   base::MD5Digest digest;
   base::MD5Final(&digest, &ctx);
-  list->Append(Value::CreateStringValue(base::MD5DigestToBase16(digest)));
+  list->Append(base::Value::CreateStringValue(base::MD5DigestToBase16(digest)));
   DCHECK(list->GetSize() >= 3);  // Minimum of 3 elements (size, data, hash).
 }
 
 // static
 MetricsLogSerializer::LogReadStatus MetricsLogSerializer::ReadLogsFromPrefList(
-    const ListValue& list,
+    const base::ListValue& list,
     std::vector<MetricsLogManager::SerializedLog>* local_list) {
   if (list.GetSize() == 0)
     return MakeRecallStatusHistogram(LIST_EMPTY);
   if (list.GetSize() < 3)
     return MakeRecallStatusHistogram(LIST_SIZE_TOO_SMALL);
 
   // The size is stored at the beginning of the list.
   int size;
   bool valid = (*list.begin())->GetAsInteger(&size);
   if (!valid)
     return MakeRecallStatusHistogram(LIST_SIZE_MISSING);
   // Account for checksum and size included in the list.
   if (static_cast<unsigned int>(size) !=
       list.GetSize() - kChecksumEntryCount) {
     return MakeRecallStatusHistogram(LIST_SIZE_CORRUPTION);
   }
 
   // Allocate strings for all of the logs we are going to read in.
   // Do this ahead of time so that we can decode the string values directly into
   // the elements of |local_list|, and thereby avoid making copies of the
   // serialized logs, which can be fairly large.
   DCHECK(local_list->empty());
   local_list->resize(size);
 
   base::MD5Context ctx;
   base::MD5Init(&ctx);
   std::string encoded_log;
   size_t local_index = 0;
-  for (ListValue::const_iterator it = list.begin() + 1;
+  for (base::ListValue::const_iterator it = list.begin() + 1;
        it != list.end() - 1;  // Last element is the checksum.
        ++it, ++local_index) {
     bool valid = (*it)->GetAsString(&encoded_log);
     if (!valid) {
       local_list->clear();
       return MakeRecallStatusHistogram(LOG_STRING_CORRUPTION);
     }
 
     base::MD5Update(&ctx, encoded_log);
 
@@ skipping 16 matching lines @@
   if (!valid) {
     local_list->clear();
     return MakeRecallStatusHistogram(CHECKSUM_STRING_CORRUPTION);
   }
   if (recovered_md5 != base::MD5DigestToBase16(digest)) {
     local_list->clear();
     return MakeRecallStatusHistogram(CHECKSUM_CORRUPTION);
   }
   return MakeRecallStatusHistogram(RECALL_SUCCESS);
 }