Move RuntimeData and related permissions out of Extension class

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 <vector>
 
 #include "base/bind.h"
 #include "base/hash_tables.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 "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/permissions/permissions_data.h"
+#include "chrome/common/extensions/permissions/socket_permission.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;
@@ skipping 168 matching lines @@
     case Socket::TYPE_UDP:
       operation_type = SocketPermissionRequest::UDP_SEND_TO;
       break;
     default:
       NOTREACHED() << "Unknown socket type.";
       operation_type = SocketPermissionRequest::NONE;
       break;
   }
 
   SocketPermission::CheckParam param(operation_type, hostname_, port_);
-  if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-        &param)) {
+  if (!PermissionsData::CheckAPIPermissionWithParam(
+          GetExtension(), APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   StartDnsLookup(hostname_);
 }
 
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
@@ skipping 42 matching lines @@
 
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   if (socket->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(
         SocketPermissionRequest::UDP_BIND, address_, port_);
-    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-          &param)) {
+    if (!PermissionsData::CheckAPIPermissionWithParam(
+            GetExtension(),
+            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 13 matching lines @@
   return true;
 }
 
 void SocketListenFunction::Work() {
   int result = -1;
 
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     SocketPermission::CheckParam param(
         SocketPermissionRequest::TCP_LISTEN, params_->address, params_->port);
-    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-          &param)) {
+    if (!PermissionsData::CheckAPIPermissionWithParam(
+            GetExtension(),
+            APIPermission::kSocket,
+            &param)) {
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(result));
       return;
     }
 
     result = socket->Listen(
         params_->address,
         params_->port,
         params_->backlog.get() ? *params_->backlog.get() : 5,
         &error_);
@@ skipping 189 matching lines @@
   if (!socket_) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   if (socket_->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(SocketPermissionRequest::UDP_SEND_TO,
         hostname_, port_);
-    if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-          &param)) {
+    if (!PermissionsData::CheckAPIPermissionWithParam(
+            GetExtension(),
+            APIPermission::kSocket,
+            &param)) {
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(-1));
       AsyncWorkCompleted();
       return;
     }
   }
 
   StartDnsLookup(hostname_);
 }
 
@@ skipping 184 matching lines @@
     error_ = kMulticastSocketTypeError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
 
-  if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-                                                   &param)) {
+  if (!PermissionsData::CheckAPIPermissionWithParam(
+          GetExtension(), APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->JoinGroup(params_->address);
   if (result != 0) {
     error_ = net::ErrorToString(result);
   }
   SetResult(Value::CreateIntegerValue(result));
@@ skipping 24 matching lines @@
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
-  if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-                                                   &param)) {
+  if (!PermissionsData::CheckAPIPermissionWithParam(GetExtension(),
+                                                    APIPermission::kSocket,
+                                                    &param)) {
     error_ = kPermissionError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->LeaveGroup(params_->address);
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(Value::CreateIntegerValue(result));
 }
@@ skipping 87 matching lines @@
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
-  if (!GetExtension()->CheckAPIPermissionWithParam(APIPermission::kSocket,
-        &param)) {
+  if (!PermissionsData::CheckAPIPermissionWithParam(
+          GetExtension(),
+          APIPermission::kSocket,
+          &param)) {
     error_ = kPermissionError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   base::ListValue* values = new base::ListValue();
   values->AppendStrings((std::vector<std::string>&)
       static_cast<UDPSocket*>(socket)->GetJoinedGroups());
   SetResult(values);
 }
 
 }  // namespace extensions