Refactor APIResourceController to ProfileKeyedService.

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/api/api_resource_controller.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"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 const char kConnectionIdKey[] = "connectionId";
 const char kPortsKey[] = "ports";
 const char kDataKey[] = "data";
 const char kBytesReadKey[] = "bytesRead";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kBitrateKey[] = "bitrate";
 const char kOptionsKey[] = "options";
 const char kSuccessKey[] = "success";
 const char kDtrKey[] = "dtr";
 const char kRtsKey[] = "rts";
 const char kDcdKey[] = "dcd";
 const char kCtsKey[] = "cts";
 
 const char kErrorGetControlSignalsFailed[] = "Failed to get control signals.";
 const char kErrorSetControlSignalsFailed[] = "Failed to set control signals.";
 
+SerialAsyncApiFunction::SerialAsyncApiFunction()
+    : manager_(NULL) {
+}
+
+SerialAsyncApiFunction::~SerialAsyncApiFunction() {
+}
+
+bool SerialAsyncApiFunction::PrePrepare() {
+  manager_ = ExtensionSystem::Get(profile())->serial_connection_manager();
+  return manager_ != NULL;
+}
+
 SerialGetPortsFunction::SerialGetPortsFunction() {}
 
 bool SerialGetPortsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
   return true;
 }
 
 void SerialGetPortsFunction::Work() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
@@ skipping 53 matching lines @@
 void SerialOpenFunction::Work() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   const SerialPortEnumerator::StringSet name_set(
     SerialPortEnumerator::GenerateValidSerialPortNames());
   if (DoesPortExist(params_->port)) {
     SerialConnection* serial_connection = CreateSerialConnection(
       params_->port,
       bitrate_,
       event_notifier_);
     CHECK(serial_connection);
-    int id = controller()->AddAPIResource(serial_connection);
+    int id = manager_->Add(serial_connection);
     CHECK(id);
 
     bool open_result = serial_connection->Open();
     if (!open_result) {
       serial_connection->Close();
-      controller()->RemoveSerialConnection(id);
+      manager_->Remove(id);
       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) {
+    ApiResourceEventNotifier* event_notifier) {
   return new SerialConnection(port, bitrate, 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::experimental_serial::Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
+
   return true;
 }
 
 void SerialCloseFunction::Work() {
   bool close_result = false;
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
     serial_connection->Close();
-    controller()->RemoveSerialConnection(params_->connection_id);
+    manager_->Remove(params_->connection_id);
     close_result = true;
   }
 
   SetResult(Value::CreateBooleanValue(close_result));
 }
 
 bool SerialCloseFunction::Respond() {
   return true;
 }
 
 SerialReadFunction::SerialReadFunction() {
 }
 
 SerialReadFunction::~SerialReadFunction() {
 }
 
 bool SerialReadFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::experimental_serial::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
+
   return true;
 }
 
 void SerialReadFunction::Work() {
   uint8 byte = '\0';
   int bytes_read = -1;
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection)
     bytes_read = serial_connection->Read(&byte);
 
   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;
   result->SetInteger(kBytesReadKey, bytes_read);
@@ skipping 20 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   io_buffer_size_ = params_->data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(params_->data->GetBuffer());
 
   return true;
 }
 
 void SerialWriteFunction::Work() {
   int bytes_written = -1;
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(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::experimental_serial::Flush::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SerialFlushFunction::Work() {
   bool flush_result = false;
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
     serial_connection->Flush();
     flush_result = true;
   }
 
   SetResult(Value::CreateBooleanValue(flush_result));
 }
 
 bool SerialFlushFunction::Respond() {
   return true;
 }
 
 SerialGetControlSignalsFunction::SerialGetControlSignalsFunction()
     : api_response_(false) {
 }
 
 SerialGetControlSignalsFunction::~SerialGetControlSignalsFunction() {
 }
 
 bool SerialGetControlSignalsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::experimental_serial::GetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
+
   return true;
 }
 
 void SerialGetControlSignalsFunction::Work() {
   DictionaryValue *result = new DictionaryValue();
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(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 13 matching lines @@
 
 SerialSetControlSignalsFunction::~SerialSetControlSignalsFunction() {
 }
 
 bool SerialSetControlSignalsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::experimental_serial::SetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
+
   return true;
 }
 
 void SerialSetControlSignalsFunction::Work() {
-  SerialConnection* serial_connection =
-      controller()->GetSerialConnection(params_->connection_id);
+  SerialConnection* serial_connection = manager_->Get(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