Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/serial/serial_api.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/extensions/api/serial/serial_api.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
@@ skipping 42 matching lines @@
 SerialGetPortsFunction::SerialGetPortsFunction() {}
 
 bool SerialGetPortsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
   return true;
 }
 
 void SerialGetPortsFunction::Work() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  ListValue* ports = new ListValue();
+  base::ListValue* ports = new base::ListValue();
   SerialPortEnumerator::StringSet port_names =
       SerialPortEnumerator::GenerateValidSerialPortNames();
   SerialPortEnumerator::StringSet::const_iterator i = port_names.begin();
   while (i != port_names.end()) {
     ports->Append(Value::CreateStringValue(*i++));
   }
 
   SetResult(ports);
 }
 
@@ skipping 15 matching lines @@
 SerialOpenFunction::~SerialOpenFunction() {
 }
 
 bool SerialOpenFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::Open::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   if (params_->options.get()) {
-    scoped_ptr<DictionaryValue> options = params_->options->ToValue();
+    scoped_ptr<base::DictionaryValue> options = params_->options->ToValue();
     if (options->HasKey(kBitrateKey))
       EXTENSION_FUNCTION_VALIDATE(options->GetInteger(kBitrateKey, &bitrate_));
   }
 
   return true;
 }
 
 void SerialOpenFunction::AsyncWorkStart() {
   Work();
 }
@@ skipping 11 matching lines @@
     int id = manager_->Add(serial_connection);
     CHECK(id);
 
     bool open_result = serial_connection->Open();
     if (!open_result) {
       serial_connection->Close();
       RemoveSerialConnection(id);
       id = -1;
     }
 
-    DictionaryValue* result = new DictionaryValue();
+    base::DictionaryValue* result = new base::DictionaryValue();
     result->SetInteger(kConnectionIdKey, id);
     SetResult(result);
     AsyncWorkCompleted();
   } else {
-    DictionaryValue* result = new DictionaryValue();
+    base::DictionaryValue* result = new base::DictionaryValue();
     result->SetInteger(kConnectionIdKey, -1);
     SetResult(result);
     AsyncWorkCompleted();
   }
 }
 
 SerialConnection* SerialOpenFunction::CreateSerialConnection(
     const std::string& port,
     int bitrate,
     const std::string& owner_extension_id) {
@@ skipping 64 matching lines @@
 void SerialReadFunction::Work() {
   int bytes_read = -1;
   scoped_refptr<net::IOBufferWithSize> io_buffer(
       new net::IOBufferWithSize(params_->bytes_to_read));
   SerialConnection* serial_connection(GetSerialConnection(
       params_->connection_id));
 
   if (serial_connection)
     bytes_read = serial_connection->Read(io_buffer);
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
 
   // The API is defined to require a 'data' value, so we will always
   // create a BinaryValue, even if it's zero-length.
   if (bytes_read < 0)
     bytes_read = 0;
   result->SetInteger(kBytesReadKey, bytes_read);
   result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(
       io_buffer->data(), bytes_read));
   SetResult(result);
 }
@@ skipping 23 matching lines @@
 
 void SerialWriteFunction::Work() {
   int bytes_written = -1;
   SerialConnection* serial_connection = GetSerialConnection(
       params_->connection_id);
   if (serial_connection)
     bytes_written = serial_connection->Write(io_buffer_, io_buffer_size_);
   else
     error_ = kSerialConnectionNotFoundError;
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 }
 
 bool SerialWriteFunction::Respond() {
   return true;
 }
 
 SerialFlushFunction::SerialFlushFunction() {
 }
@@ skipping 35 matching lines @@
 bool SerialGetControlSignalsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::GetControlSignals::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialGetControlSignalsFunction::Work() {
-  DictionaryValue *result = new DictionaryValue();
+  base::DictionaryValue *result = new base::DictionaryValue();
   SerialConnection* serial_connection = GetSerialConnection(
       params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
     if (serial_connection->GetControlSignals(control_signals)) {
       api_response_ = true;
       result->SetBoolean(kDcdKey, control_signals.dcd);
       result->SetBoolean(kCtsKey, control_signals.cts);
     } else {
       error_ = kErrorGetControlSignalsFailed;
@@ skipping 46 matching lines @@
     error_ = kSerialConnectionNotFoundError;
     SetResult(Value::CreateBooleanValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions