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

chrome/browser/extensions/api/serial/serial_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/serial/serial_api.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
@@ skipping 106 matching lines @@
       params_->port,
       bitrate_,
       event_notifier_);
     CHECK(serial_connection);
     int id = manager_->Add(serial_connection);
     CHECK(id);
 
     bool open_result = serial_connection->Open();
     if (!open_result) {
       serial_connection->Close();
-      manager_->Remove(id);
+      manager_->Remove(extension_->id(), id);

[Mihai Parparita -not on Chrome, 2012/09/11 07:18:19]

Don't feel too strongly about this, but rather than having to repeat the
extension ID every call-site, you may want to add
GetSocket/RemoveSocket(socketId) protected methods to SerialAsyncApiFunction.

(applies for other APIs too)

       id = -1;
     }
 
     DictionaryValue* result = new DictionaryValue();
     result->SetInteger(kConnectionIdKey, id);
     SetResult(result);
     AsyncWorkCompleted();
   } else {
     DictionaryValue* result = new DictionaryValue();
     result->SetInteger(kConnectionIdKey, -1);
     SetResult(result);
     AsyncWorkCompleted();
   }
 }
 
 SerialConnection* SerialOpenFunction::CreateSerialConnection(
     const std::string& port,
     int bitrate,
     ApiResourceEventNotifier* event_notifier) {
-  return new SerialConnection(port, bitrate, event_notifier);
+  return new SerialConnection(port, bitrate, extension_->id(), event_notifier);
 }
 
 bool SerialOpenFunction::DoesPortExist(const std::string& port) {
   const SerialPortEnumerator::StringSet name_set(
     SerialPortEnumerator::GenerateValidSerialPortNames());
   return SerialPortEnumerator::DoesPortExist(name_set, params_->port);
 }
 
 bool SerialOpenFunction::Respond() {
   return true;
 }
 
 SerialCloseFunction::SerialCloseFunction() {
 }
 
 SerialCloseFunction::~SerialCloseFunction() {
 }
 
 bool SerialCloseFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialCloseFunction::Work() {
   bool close_result = false;
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(extension_->id(),
+                                                      params_->connection_id);
   if (serial_connection) {
     serial_connection->Close();
-    manager_->Remove(params_->connection_id);
+    manager_->Remove(extension_->id(), params_->connection_id);
     close_result = true;
   }
 
   SetResult(Value::CreateBooleanValue(close_result));
 }
 
 bool SerialCloseFunction::Respond() {
   return true;
 }
 
@@ skipping 13 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void SerialReadFunction::Work() {
   int bytes_read = -1;
   scoped_refptr<net::IOBufferWithSize> io_buffer(
       new net::IOBufferWithSize(params_->bytes_to_read));
-  SerialConnection* serial_connection(manager_->Get(params_->connection_id));
+  SerialConnection* serial_connection(manager_->Get(extension_->id(),
+                                                    params_->connection_id));
 
   if (serial_connection)
     bytes_read = serial_connection->Read(io_buffer);
 
   DictionaryValue* result = new DictionaryValue();
 
   // The API is defined to require a 'data' value, so we will always
   // create a BinaryValue, even if it's zero-length.
   if (bytes_read < 0)
     bytes_read = 0;
@@ skipping 21 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   io_buffer_size_ = params_->data.size();
   io_buffer_ = new net::WrappedIOBuffer(params_->data.data());
 
   return true;
 }
 
 void SerialWriteFunction::Work() {
   int bytes_written = -1;
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(extension_->id(),
+                                                      params_->connection_id);
   if (serial_connection)
     bytes_written = serial_connection->Write(io_buffer_, io_buffer_size_);
   else
     error_ = kSerialConnectionNotFoundError;
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 }
 
@@ skipping 10 matching lines @@
 bool SerialFlushFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::Flush::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SerialFlushFunction::Work() {
   bool flush_result = false;
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(extension_->id(),
+                                                      params_->connection_id);
   if (serial_connection) {
     serial_connection->Flush();
     flush_result = true;
   }
 
   SetResult(Value::CreateBooleanValue(flush_result));
 }
 
 bool SerialFlushFunction::Respond() {
   return true;
@@ skipping 11 matching lines @@
 
   params_ = api::serial::GetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialGetControlSignalsFunction::Work() {
   DictionaryValue *result = new DictionaryValue();
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(extension_->id(),
+                                                      params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
     if (serial_connection->GetControlSignals(control_signals)) {
       api_response_ = true;
       result->SetBoolean(kDcdKey, control_signals.dcd);
       result->SetBoolean(kCtsKey, control_signals.cts);
     } else {
       error_ = kErrorGetControlSignalsFailed;
     }
   } else {
@@ skipping 18 matching lines @@
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::SetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialSetControlSignalsFunction::Work() {
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(extension_->id(),
+                                                      params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
     control_signals.should_set_dtr = params_->options.dtr.get() != NULL;
     if (control_signals.should_set_dtr)
       control_signals.dtr = *(params_->options.dtr);
     control_signals.should_set_rts = params_->options.rts.get() != NULL;
     if (control_signals.should_set_rts)
       control_signals.rts = *(params_->options.rts);
     if (serial_connection->SetControlSignals(control_signals)) {
       SetResult(Value::CreateBooleanValue(true));
     } else {
       error_ = kErrorSetControlSignalsFailed;
       SetResult(Value::CreateBooleanValue(false));
     }
   } else {
     error_ = kSerialConnectionNotFoundError;
     SetResult(Value::CreateBooleanValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions