Make sure that a given app/extension requests only its own resources.

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/permissions/socket_permission.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
@@ skipping 112 matching lines @@
     src_id_ = ExtractSrcId(options.get());
     event_notifier_ = CreateEventNotifier(src_id_);
   }
 
   return true;
 }
 
 void SocketCreateFunction::Work() {
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
-    socket = new TCPSocket(event_notifier_);
+    socket = new TCPSocket(extension_->id(), event_notifier_);
   } else if (socket_type_== kSocketTypeUDP) {
-    socket = new UDPSocket(event_notifier_);
+    socket = new UDPSocket(extension_->id(), event_notifier_);
   }
   DCHECK(socket);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kSocketIdKey, manager_->Add(socket));
   SetResult(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() {
-  manager_->Remove(socket_id_);
+  manager_->Remove(extension_->id(), socket_id_);
 }
 
 SocketConnectFunction::SocketConnectFunction()
     : socket_id_(0),
       port_(0) {
 }
 
 SocketConnectFunction::~SocketConnectFunction() {
 }
 
 bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
-  socket_ = manager_->Get(socket_id_);
+  socket_ = manager_->Get(extension_->id(), socket_id_);
   if (!socket_) {
     error_ = kSocketNotFoundError;
     SetResult(Value::CreateIntegerValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   SocketPermissionData::OperationType operation_type;
   switch (socket_->GetSocketType()) {
     case Socket::TYPE_TCP:
@@ skipping 38 matching lines @@
   SetResult(Value::CreateIntegerValue(result));
   AsyncWorkCompleted();
 }
 
 bool SocketDisconnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDisconnectFunction::Work() {
-  Socket* socket = manager_->Get(socket_id_);
+  Socket* socket = manager_->Get(extension_->id(), socket_id_);
   if (socket)
     socket->Disconnect();
   else
     error_ = kSocketNotFoundError;
   SetResult(Value::CreateNullValue());
 }
 
 bool SocketBindFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &address_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketBindFunction::Work() {
   int result = -1;
-  Socket* socket = manager_->Get(socket_id_);
+  Socket* socket = manager_->Get(extension_->id(), 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_);
@@ skipping 15 matching lines @@
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
   params_ = api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
-  Socket* socket = manager_->Get(params_->socket_id);
+  Socket* socket = manager_->Get(extension_->id(), params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL);
     return;
   }
 
   socket->Read(params_->buffer_size.get() ? *params_->buffer_size.get() : 4096,
                base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
@@ skipping 27 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   base::BinaryValue *data = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketWriteFunction::AsyncWorkStart() {
-  Socket* socket = manager_->Get(socket_id_);
+  Socket* socket = manager_->Get(extension_->id(), socket_id_);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1);
     return;
   }
 
   socket->Write(io_buffer_, io_buffer_size_,
                 base::Bind(&SocketWriteFunction::OnCompleted, this));
 }
@@ skipping 12 matching lines @@
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
 bool SocketRecvFromFunction::Prepare() {
   params_ = api::socket::RecvFrom::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketRecvFromFunction::AsyncWorkStart() {
-  Socket* socket = manager_->Get(params_->socket_id);
+  Socket* socket = manager_->Get(extension_->id(), params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL, std::string(), 0);
     return;
   }
 
   socket->RecvFrom(params_->buffer_size.get() ? *params_->buffer_size : 4096,
                    base::Bind(&SocketRecvFromFunction::OnCompleted, this));
 }
 
@@ skipping 34 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port_));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
-  socket_ = manager_->Get(socket_id_);
+  socket_ = manager_->Get(extension_->id(), 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,
         hostname_, port_);
@@ skipping 38 matching lines @@
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
 bool SocketSetKeepAliveFunction::Prepare() {
   params_ = api::socket::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetKeepAliveFunction::Work() {
   bool result = false;
-  Socket* socket = manager_->Get(params_->socket_id);
+  Socket* socket = manager_->Get(extension_->id(), params_->socket_id);
   if (socket) {
     int delay = 0;
     if (params_->delay.get())
       delay = *params_->delay;
     result = socket->SetKeepAlive(params_->enable, delay);
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(Value::CreateBooleanValue(result));
 }
 
 SocketSetNoDelayFunction::SocketSetNoDelayFunction()
     : params_(NULL) {
 }
 
 SocketSetNoDelayFunction::~SocketSetNoDelayFunction() {}
 
 bool SocketSetNoDelayFunction::Prepare() {
   params_ = api::socket::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
-  Socket* socket = manager_->Get(params_->socket_id);
+  Socket* socket = manager_->Get(extension_->id(), 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::socket::GetInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetInfoFunction::Work() {
   api::socket::SocketInfo info;
-  Socket* socket = manager_->Get(params_->socket_id);
+  Socket* socket = manager_->Get(extension_->id(), params_->socket_id);
   if (socket) {
     // This represents what we know about the socket, and does not call through
     // to the system.
     switch (socket->GetSocketType()) {
       case Socket::TYPE_TCP:
         info.socket_type = kTCPOption;
         break;
       case Socket::TYPE_UDP:
         info.socket_type = kUDPOption;
         break;
@@ skipping 22 matching lines @@
           new std::string(localAddress.ToStringWithoutPort()));
       info.local_port.reset(new int(localAddress.port()));
     }
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(info.ToValue().release());
 }
 
 }  // namespace extensions