Add bufferSize argument of socket.read() and socket.recvFrom()

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 "base/bind.h"
 #include "chrome/browser/extensions/api/api_resource_controller.h"
 #include "chrome/browser/extensions/api/socket/socket.h"
 #include "chrome/browser/extensions/api/socket/tcp_socket.h"
 #include "chrome/browser/extensions/api/socket/udp_socket.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/common/extensions/api/experimental.socket.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
@@ skipping 111 matching lines @@
   Socket* socket = controller()->GetSocket(socket_id_);
   if (socket)
     result = socket->Bind(address_, port_);
   else
     error_ = kSocketNotFoundError;
 
   result_.reset(Value::CreateIntegerValue(result));
 }
 
 bool SocketReadFunction::Prepare() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
+  scoped_ptr<api::experimental_socket::Read::Params> params(
+      api::experimental_socket::Read::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  socket_id_ = params->socket_id;
+  buffer_size_ = params->buffer_size.get() ? *params->buffer_size : 4096;
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
   Socket* socket = controller()->GetSocket(socket_id_);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL);
     return;
   }
 
-  // TODO(miket): this is an arbitrary number. Can we come up with one that
-  // makes sense?
-  const int buffer_len = 2048;
-  socket->Read(buffer_len,
+  socket->Read(buffer_size_,
       base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer) {
   // TODO(miket): the buffer-to-array functionality appears twice, once here
   // and once in socket.cc. When serial etc. is converted over, it'll appear
   // there, too. What's a good single place for it to live? Keep in mind that
   // this is short-term code, to be replaced with ArrayBuffer code.
   DictionaryValue* result = new DictionaryValue();
@@ skipping 58 matching lines @@
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   result_.reset(result);
 
   AsyncWorkCompleted();
 }
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
 bool SocketRecvFromFunction::Prepare() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
+  scoped_ptr<api::experimental_socket::RecvFrom::Params> params(
+      api::experimental_socket::RecvFrom::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  socket_id_ = params->socket_id;
+  buffer_size_ = params->buffer_size.get() ? *params->buffer_size : 4096;
   return true;
 }
 
 void SocketRecvFromFunction::AsyncWorkStart() {
   Socket* socket = controller()->GetSocket(socket_id_);
   // TODO(miket): this is an arbitrary number. Can we come up with one that
   // makes sense?
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL, std::string(), 0);
     return;
   }
 
-  const int buffer_len = 2048;
-  socket->RecvFrom(buffer_len,
+  socket->RecvFrom(buffer_size_,
       base::Bind(&SocketRecvFromFunction::OnCompleted, this));
 }
 
 void SocketRecvFromFunction::OnCompleted(int bytes_read,
                                          scoped_refptr<net::IOBuffer> io_buffer,
                                          const std::string& address,
                                          int port) {
   // TODO(miket): the buffer-to-array functionality appears twice, once here
   // and once in socket.cc. When serial etc. is converted over, it'll appear
   // there, too. What's a good single place for it to live? Keep in mind that
@@ skipping 62 matching lines @@
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   result_.reset(result);
 
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions