Remove base::BinaryValue

extensions/browser/api/socket/socket_api.cc

 // Copyright 2014 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 "extensions/browser/api/socket/socket_api.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 501 matching lines @@
   socket->Read(params_->buffer_size.get() ? *params_->buffer_size : 4096,
                base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer,
                                      bool socket_destroying) {
   std::unique_ptr<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));
+    result->Set(kDataKey, base::Value::CreateWithCopiedBuffer(io_buffer->data(),
+                                                              bytes_read));
   } else {
     result->Set(kDataKey, new base::Value(base::Value::Type::BINARY));
   }
   SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketWriteFunction::SocketWriteFunction()
     : socket_id_(0), io_buffer_(NULL), io_buffer_size_(0) {}
 
 SocketWriteFunction::~SocketWriteFunction() {}
 
 bool SocketWriteFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::BinaryValue* data = NULL;
+  base::Value* data = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketWriteFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
 
@@ skipping 39 matching lines @@
 }
 
 void SocketRecvFromFunction::OnCompleted(int bytes_read,
                                          scoped_refptr<net::IOBuffer> io_buffer,
                                          bool socket_destroying,
                                          const std::string& address,
                                          uint16_t port) {
   std::unique_ptr<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));
+    result->Set(kDataKey, base::Value::CreateWithCopiedBuffer(io_buffer->data(),
+                                                              bytes_read));
   } else {
     result->Set(kDataKey, new base::Value(base::Value::Type::BINARY));
   }
   result->SetString(kAddressKey, address);
   result->SetInteger(kPortKey, port);
   SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketSendToFunction::SocketSendToFunction()
     : socket_id_(0), io_buffer_(NULL), io_buffer_size_(0), port_(0) {
 }
 
 SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::BinaryValue* data = NULL;
+  base::Value* data = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   int port;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port));
   if (!IsPortValid(port)) {
     error_ = kPortInvalidError;
     return false;
   }
   port_ = static_cast<uint16_t>(port);
 
@@ skipping 457 matching lines @@
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions