Multicast 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/common/extensions/extension.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 20 matching lines @@
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
 const char kPermissionError[] = "App does not have permission";
 const char kNetworkListError[] = "Network lookup failed or unsupported";
 const char kTCPSocketBindError[] =
     "TCP socket does not support bind. For TCP server please use listen.";
+const char kMulticastSocketTypeError[] =
+    "Only UDP socket supports multicast.";
+const char kWildcardArress[] = "*";
+const int kWildcardPortNumber = 0;
 
 SocketAsyncApiFunction::SocketAsyncApiFunction()
     : manager_(NULL) {
 }
 
 SocketAsyncApiFunction::~SocketAsyncApiFunction() {
 }
 
 bool SocketAsyncApiFunction::PrePrepare() {
   manager_ = ExtensionSystem::Get(profile())->socket_manager();
@@ skipping 323 matching lines @@
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer) {
   DictionaryValue* result = new 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);
 
   AsyncWorkCompleted();
 }
 
 SocketWriteFunction::SocketWriteFunction()
     : socket_id_(0),
@@ skipping 279 matching lines @@
         make_linked_ptr(new api::socket::NetworkInterface);
     info->name = i->name;
     info->address = net::IPAddressToString(i->address);
     create_arg.push_back(info);
   }
 
   results_ = api::socket::GetNetworkList::Results::Create(create_arg);
   SendResponse(true);
 }
 
+SocketJoinGroupFunction::SocketJoinGroupFunction()
+  : params_(NULL) {}

[mmenke, 2013/04/12 21:07:41]

4 space indent.  Comment applies to whole file.

[Bei Zhang, 2013/04/15 22:30:26]

Done.

+
+SocketJoinGroupFunction::~SocketJoinGroupFunction() {}
+
+bool SocketJoinGroupFunction::Prepare() {
+  params_ = api::socket::JoinGroup::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketJoinGroupFunction::Work() {
+  int result = -1;
+  Socket* socket = GetSocket(params_->socket_id);
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  if (socket->GetSocketType() == Socket::TYPE_UDP) {
+    SocketPermission::CheckParam param(
+        SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP,
+        kWildcardArress,
+        kWildcardPortNumber);
+    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
+          &param)) {

[mmenke, 2013/04/12 21:07:41]

Should either be aligned with APIPermission::kSocket, or
"APIPermission::kSocket" should be on the next line, and both should be indented
4 spaces (Can optionally put them both on the same line, but should be indented
4 spaces more than the start of the "!GetExtension()").

Comment applies to whole file.

[Bei Zhang, 2013/04/15 22:30:26]

Done.

+      error_ = kPermissionError;
+      SetResult(Value::CreateIntegerValue(result));
+      return;
+    }
+  } else {
+    error_ = kMulticastSocketTypeError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  result = static_cast<UDPSocket*>(socket)->JoinGroup(params_->address);
+  if (result != 0) {
+    error_ = net::ErrorToString(result);
+  }
+  SetResult(Value::CreateIntegerValue(result));
+}
+
+
+SocketLeaveGroupFunction::SocketLeaveGroupFunction()
+  : params_(NULL) {}
+
+SocketLeaveGroupFunction::~SocketLeaveGroupFunction() {}
+
+bool SocketLeaveGroupFunction::Prepare() {
+  params_ = api::socket::LeaveGroup::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketLeaveGroupFunction::Work() {
+  int result = -1;
+  Socket* socket = GetSocket(params_->socket_id);
+
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  if (socket->GetSocketType() == Socket::TYPE_UDP) {
+    SocketPermission::CheckParam param(
+        SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP,
+        kWildcardArress,
+        kWildcardPortNumber);
+    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
+          &param)) {
+      error_ = kPermissionError;
+      SetResult(Value::CreateIntegerValue(result));
+      return;
+    }
+  } else {
+    error_ = kMulticastSocketTypeError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  result = static_cast<UDPSocket*>(socket)->LeaveGroup(params_->address);
+  if (result != 0) {
+    error_ = net::ErrorToString(result);
+  }
+  SetResult(Value::CreateIntegerValue(result));
+}
+
+SocketSetMulticastTimeToLiveFunction::SocketSetMulticastTimeToLiveFunction()
+  : params_(NULL) {}
+
+SocketSetMulticastTimeToLiveFunction::~SocketSetMulticastTimeToLiveFunction() {}
+
+bool SocketSetMulticastTimeToLiveFunction::Prepare() {
+  params_ = api::socket::SetMulticastTimeToLive::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+void SocketSetMulticastTimeToLiveFunction::Work() {
+  int result = -1;
+  Socket* socket = GetSocket(params_->socket_id);
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  if (socket->GetSocketType() == Socket::TYPE_UDP) {
+    result = static_cast<UDPSocket*>(socket)->
+          SetMulticastTimeToLive(params_->ttl);
+      if (result != 0) {
+        error_ = net::ErrorToString(result);
+      }
+      SetResult(Value::CreateIntegerValue(result));
+  } else {
+    error_ = kMulticastSocketTypeError;
+  }
+  SetResult(Value::CreateIntegerValue(result));
+}
+
+SocketSetMulticastLoopbackModeFunction::SocketSetMulticastLoopbackModeFunction()
+  : params_(NULL) {}
+
+SocketSetMulticastLoopbackModeFunction::
+  ~SocketSetMulticastLoopbackModeFunction() {}
+
+bool SocketSetMulticastLoopbackModeFunction::Prepare() {
+  params_ = api::socket::SetMulticastLoopbackMode::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketSetMulticastLoopbackModeFunction::Work() {
+  int result = -1;
+  Socket* socket = GetSocket(params_->socket_id);
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  if (socket->GetSocketType() == Socket::TYPE_UDP) {
+    result = static_cast<UDPSocket*>(socket)->
+        SetMulticastLoopbackMode(params_->enabled);
+    if (result != 0) {
+      error_ = net::ErrorToString(result);
+    }
+  } else {
+    error_ = kMulticastSocketTypeError;
+  }
+  SetResult(Value::CreateIntegerValue(result));
+}
+
+SocketGetJoinedGroupsFunction::SocketGetJoinedGroupsFunction()
+  : params_(NULL) {}
+
+SocketGetJoinedGroupsFunction::~SocketGetJoinedGroupsFunction() {}
+
+bool SocketGetJoinedGroupsFunction::Prepare() {
+  params_ = api::socket::GetJoinedGroups::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketGetJoinedGroupsFunction::Work() {
+  int result = -1;
+  Socket* socket = GetSocket(params_->socket_id);
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  if (socket->GetSocketType() == Socket::TYPE_UDP) {
+    SocketPermission::CheckParam param(
+        SocketPermissionRequest::UDP_SEND_TO,
+        kWildcardArress,
+        kWildcardPortNumber);
+    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
+          &param)) {
+      error_ = kPermissionError;
+      SetResult(Value::CreateIntegerValue(result));
+      return;
+    }
+  } else {
+    error_ = kMulticastSocketTypeError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
+
+  base::hash_set<std::string> groups;
+  result = static_cast<UDPSocket*>(socket)->
+      GetJoinedGroups(groups);
+  if (result != 0) {
+    error_ = net::ErrorToString(result);
+  }
+  base::ListValue* list = new base::ListValue();
+  for (base::hash_set<std::string>::iterator it = groups.begin();
+      it != groups.end(); ++it) {
+    list->AppendString(*it);
+  }
+  SetResult(list);
+}
 }  // namespace extensions

[mmenke, 2013/04/12 21:07:41]

Line break before end of namespace.

[Bei Zhang, 2013/04/15 22:30:26]

Done.