Use extensions socket permission for TCP/UDP socket APIs in Pepper

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"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.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_system.h"
 #include "chrome/browser/io_thread.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 
 namespace extensions {
 
+using content::SocketPermissionRequest;
+
 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 kSocketNotFoundError[] = "Socket not found";
 const char kSocketTypeInvalidError[] = "Socket type is not supported";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
@@ skipping 139 matching lines @@
 
 void SocketConnectFunction::AsyncWorkStart() {
   socket_ = GetSocket(socket_id_);
   if (!socket_) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
-  SocketPermissionData::OperationType operation_type;
+  SocketPermissionRequest::OperationType operation_type;
   switch (socket_->GetSocketType()) {
     case Socket::TYPE_TCP:
-      operation_type = SocketPermissionData::TCP_CONNECT;
+      operation_type = SocketPermissionRequest::TCP_CONNECT;
       break;
     case Socket::TYPE_UDP:
-      operation_type = SocketPermissionData::UDP_SEND_TO;
+      operation_type = SocketPermissionRequest::UDP_SEND_TO;
       break;
     default:
       NOTREACHED() << "Unknown socket type.";
-      operation_type = SocketPermissionData::NONE;
+      operation_type = SocketPermissionRequest::NONE;
       break;
   }
 
   SocketPermission::CheckParam param(operation_type, hostname_, port_);
   if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
         &param)) {
     error_ = kPermissionError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
@@ skipping 47 matching lines @@
   Socket* socket = GetSocket(socket_id_);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   if (socket->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(
-        SocketPermissionData::UDP_BIND, address_, port_);
+        SocketPermissionRequest::UDP_BIND, address_, port_);
     if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
           &param)) {
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(result));
       return;
     }
   } else if (socket->GetSocketType() == Socket::TYPE_TCP) {
     error_ = kTCPSocketBindError;
     SetResult(Value::CreateIntegerValue(result));
     return;
@@ skipping 19 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketListenFunction::Work() {
   int result = -1;
 
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     SocketPermission::CheckParam param(
-        SocketPermissionData::TCP_LISTEN, params_->address, params_->port);
+        SocketPermissionRequest::TCP_LISTEN, params_->address, params_->port);
     if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
           &param)) {
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(result));
       return;
     }
 
     result = socket->Listen(
         params_->address,
         params_->port,
@@ skipping 197 matching lines @@
 void SocketSendToFunction::AsyncWorkStart() {
   socket_ = GetSocket(socket_id_);
   if (!socket_) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   if (socket_->GetSocketType() == Socket::TYPE_UDP) {
-    SocketPermission::CheckParam param(SocketPermissionData::UDP_SEND_TO,
+    SocketPermission::CheckParam param(SocketPermissionRequest::UDP_SEND_TO,
         hostname_, port_);
     if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
           &param)) {
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(-1));
       AsyncWorkCompleted();
       return;
     }
   }
 
@@ skipping 157 matching lines @@
     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);
 }
 
 }  // namespace extensions