Adds socket.getInfo to the socket API

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/browser_process.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
 #include "chrome/browser/extensions/api/socket/socket.h"
@@ skipping 10 matching lines @@
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 const char kTCPOption[] = "tcp";
 const char kUDPOption[] = "udp";
+const char kSocketTypeKey[] = "socketType";
+const char kIsConnectedKey[] = "connected";
+const char kPeerAddressKey[] = "peerAddress";
+const char kPeerPortKey[] = "peerPort";
+const char kLocalAddressKey[] = "localAddress";
+const char kLocalPortKey[] = "localPort";
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kSocketTypeInvalidError[] = "Socket type is not supported";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
 
 SocketAsyncApiFunction::SocketAsyncApiFunction()
     : manager_(NULL) {
 }
 
 SocketAsyncApiFunction::~SocketAsyncApiFunction() {
@@ skipping 399 matching lines @@
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
   Socket* socket = manager_->Get(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
   SetResult(Value::CreateBooleanValue(result));
 }
 
+SocketGetInfoFunction::SocketGetInfoFunction()
+    : params_(NULL) {
+}
+
+SocketGetInfoFunction::~SocketGetInfoFunction() {}
+
+bool SocketGetInfoFunction::Prepare() {
+  params_ = api::experimental_socket::GetInfo::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketGetInfoFunction::Work() {
+  DictionaryValue* result = new DictionaryValue();
+  Socket* socket = manager_->Get(params_->socket_id);
+  if (socket) {
+    std::string type = (socket->IsTCPSocket() ? kTCPOption : kUDPOption);
+    result->Set(kSocketTypeKey, Value::CreateStringValue(type));

[benwells, 2012/07/26 04:18:37]

I think there is a nicer way to set this return value.

[thorogood, 2012/07/26 06:19:50]

I've had a go at using the generated type. How I reset the scoped_ptr feels
verbose though - I'm not sure if there's a neater way. Makes sense though:
dynamically create copy (in heap) of variable returned to me normally on the
stack, give ownership to scoped_ptr.

+    result->Set(kIsConnectedKey,
+        Value::CreateBooleanValue(socket->IsConnected()));
+
+    net::IPEndPoint peerAddress;
+    if (socket->GetPeerAddress(&peerAddress)) {
+      result->Set(kPeerAddressKey,
+          Value::CreateStringValue(peerAddress.ToStringWithoutPort()));
+      result->Set(kPeerPortKey,
+          Value::CreateIntegerValue(peerAddress.port()));
+    }
+
+    net::IPEndPoint localAddress;
+    if (socket->GetLocalAddress(&localAddress)) {
+      result->Set(kLocalAddressKey,
+          Value::CreateStringValue(localAddress.ToStringWithoutPort()));
+      result->Set(kLocalPortKey,
+          Value::CreateIntegerValue(localAddress.port()));
+    }
+  } else {
+    error_ = kSocketNotFoundError;
+  }
+  SetResult(result);
+}
+
 }  // namespace extensions