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

chrome/browser/extensions/api/bluetooth/bluetooth_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/bluetooth/bluetooth_api.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_factory.h"
@@ skipping 211 matching lines @@
 
   BluetoothDevice* device = adapter->GetDevice(options.device.address);
   if (!device) {
     SetError(kInvalidDevice);
     SendResponse(false);
     return false;
   }
 
   BluetoothDevice::ServiceList service_list = device->GetServices();
 
-  ListValue* profiles = new ListValue;
+  base::ListValue* profiles = new base::ListValue;
   for (BluetoothDevice::ServiceList::const_iterator iter = service_list.begin();
        iter != service_list.end();
        ++iter) {
     bluetooth::Profile api_profile;
     api_profile.uuid = *iter;
     profiles->Append(api_profile.ToValue().release());
   }
 
   SetResult(profiles);
   SendResponse(true);
@@ skipping 98 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::GetServicesOptions& options = params->options;
 
   BluetoothDevice* device = adapter->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
     SendResponse(false);
     return false;
   }
 
-  ListValue* services = new ListValue;
+  base::ListValue* services = new base::ListValue;
   SetResult(services);
 
   device->GetServiceRecords(
       base::Bind(&BluetoothGetServicesFunction::GetServiceRecordsCallback,
                  this,
                  services),
       base::Bind(&BluetoothGetServicesFunction::OnErrorCallback,
                  this));
 
   return true;
@@ skipping 100 matching lines @@
 BluetoothWriteFunction::BluetoothWriteFunction()
     : success_(false),
       data_to_write_(NULL) {
 }
 
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 bool BluetoothWriteFunction::Prepare() {
   // TODO(bryeung): update to new-style parameter passing when ArrayBuffer
   // support is added
-  DictionaryValue* options;
+  base::DictionaryValue* options;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
 
-  DictionaryValue* socket;
+  base::DictionaryValue* socket;
   EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("socket", &socket));
 
   int socket_id;
   EXTENSION_FUNCTION_VALIDATE(socket->GetInteger("id", &socket_id));
 
   socket_ = GetEventRouter(profile())->GetSocket(socket_id);
   if (socket_.get() == NULL) {
     SetError(kSocketNotFoundError);
     return false;
   }
@@ skipping 13 matching lines @@
     return;
 
   scoped_refptr<net::WrappedIOBuffer> wrapped_io_buffer(
       new net::WrappedIOBuffer(data_to_write_->GetBuffer()));
   scoped_refptr<net::DrainableIOBuffer> drainable_io_buffer(
       new net::DrainableIOBuffer(wrapped_io_buffer.get(),
                                  data_to_write_->GetSize()));
   success_ = socket_->Send(drainable_io_buffer.get());
   if (success_) {
     if (drainable_io_buffer->BytesConsumed() > 0)
-      SetResult(
-          Value::CreateIntegerValue(drainable_io_buffer->BytesConsumed()));
+      SetResult(base::Value::CreateIntegerValue(
+          drainable_io_buffer->BytesConsumed()));
     else
       results_.reset();
   } else {
     SetError(socket_->GetLastErrorMessage());
   }
 }
 
 bool BluetoothWriteFunction::Respond() {
   return success_;
 }
 
 void BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback() {
   SetError(kCouldNotSetOutOfBandPairingData);
   SendResponse(false);
 }
 
 bool BluetoothSetOutOfBandPairingDataFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   // TODO(bryeung): update to new-style parameter passing when ArrayBuffer
   // support is added
-  DictionaryValue* options;
+  base::DictionaryValue* options;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
   std::string address;
   EXTENSION_FUNCTION_VALIDATE(options->GetString("deviceAddress", &address));
 
   BluetoothDevice* device = adapter->GetDevice(address);
   if (!device) {
     SetError(kInvalidDevice);
     SendResponse(false);
     return false;
   }
 
   if (options->HasKey("data")) {
-    DictionaryValue* data_in;
+    base::DictionaryValue* data_in;
     EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
 
     device::BluetoothOutOfBandPairingData data_out;
 
     base::BinaryValue* tmp_data;
     EXTENSION_FUNCTION_VALIDATE(data_in->GetBinary("hash", &tmp_data));
     EXTENSION_FUNCTION_VALIDATE(
         tmp_data->GetSize() == device::kBluetoothOutOfBandPairingDataSize);
     memcpy(data_out.hash,
         reinterpret_cast<uint8_t*>(tmp_data->GetBuffer()),
@@ skipping 27 matching lines @@
     const device::BluetoothOutOfBandPairingData& data) {
   base::BinaryValue* hash = base::BinaryValue::CreateWithCopiedBuffer(
       reinterpret_cast<const char*>(data.hash),
       device::kBluetoothOutOfBandPairingDataSize);
   base::BinaryValue* randomizer = base::BinaryValue::CreateWithCopiedBuffer(
       reinterpret_cast<const char*>(data.randomizer),
       device::kBluetoothOutOfBandPairingDataSize);
 
   // TODO(bryeung): convert to bluetooth::OutOfBandPairingData
   // when ArrayBuffer support within objects is completed.
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->Set("hash", hash);
   result->Set("randomizer", randomizer);
 
   SetResult(result);
 
   SendResponse(true);
 }
 
 void BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback() {
   SetError(kCouldNotGetLocalOutOfBandPairingData);
@@ skipping 58 matching lines @@
     adapter->StopDiscovering(
         base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
         base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
   }
 
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions