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

chrome/browser/extensions/api/socket/socket_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/socket/socket_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 133 matching lines @@
 
 void SocketCreateFunction::Work() {
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
     socket = new TCPSocket(extension_->id());
   } else if (socket_type_== kSocketTypeUDP) {
     socket = new UDPSocket(extension_->id());
   }
   DCHECK(socket);
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kSocketIdKey, manager_->Add(socket));
   SetResult(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() {
@@ skipping 176 matching lines @@
   if (socket) {
     socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
   } else {
     error_ = kSocketNotFoundError;
     OnAccept(-1, NULL);
   }
 }
 
 void SocketAcceptFunction::OnAccept(int result_code,
                                     net::TCPClientSocket *socket) {
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, result_code);
   if (socket) {
     Socket *client_socket = new TCPSocket(socket, extension_id(), true);
     result->SetInteger(kSocketIdKey, manager_->Add(client_socket));
   }
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
@@ skipping 14 matching lines @@
     OnCompleted(-1, NULL);
     return;
   }
 
   socket->Read(params_->buffer_size.get() ? *params_->buffer_size.get() : 4096,
                base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer) {
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
   SetResult(result);
 
@@ skipping 25 matching lines @@
     error_ = kSocketNotFoundError;
     OnCompleted(-1);
     return;
   }
 
   socket->Write(io_buffer_, io_buffer_size_,
                 base::Bind(&SocketWriteFunction::OnCompleted, this));
 }
 
 void SocketWriteFunction::OnCompleted(int bytes_written) {
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketRecvFromFunction::SocketRecvFromFunction() {}
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
@@ skipping 12 matching lines @@
   }
 
   socket->RecvFrom(params_->buffer_size.get() ? *params_->buffer_size : 4096,
                    base::Bind(&SocketRecvFromFunction::OnCompleted, this));
 }
 
 void SocketRecvFromFunction::OnCompleted(int bytes_read,
                                          scoped_refptr<net::IOBuffer> io_buffer,
                                          const std::string& address,
                                          int port) {
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
   result->SetString(kAddressKey, address);
   result->SetInteger(kPortKey, port);
@@ skipping 58 matching lines @@
     AsyncWorkCompleted();
   }
 }
 
 void SocketSendToFunction::StartSendTo() {
   socket_->SendTo(io_buffer_, io_buffer_size_, resolved_address_, port_,
                   base::Bind(&SocketSendToFunction::OnCompleted, this));
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketSetKeepAliveFunction::SocketSetKeepAliveFunction() {}
 
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
@@ skipping 322 matching lines @@
     return;
   }
 
   base::ListValue* values = new base::ListValue();
   values->AppendStrings((std::vector<std::string>&)
       static_cast<UDPSocket*>(socket)->GetJoinedGroups());
   SetResult(values);
 }
 
 }  // namespace extensions