Pull AsyncApiFunction out of src/chrome

chrome/browser/extensions/api/bluetooth/bluetooth_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/bluetooth/bluetooth_api.h"
 
 #include <string>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/event_names.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/bluetooth.h"
 #include "chrome/common/extensions/api/bluetooth/bluetooth_manifest_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_service_record.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_utils.h"
@@ skipping 61 matching lines @@
 ProfileKeyedAPIFactory<BluetoothAPI>* BluetoothAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 BluetoothAPI* BluetoothAPI::Get(BrowserContext* context) {
   return GetFactoryInstance()->GetForProfile(context);
 }
 
 BluetoothAPI::BluetoothAPI(BrowserContext* context)
-    : profile_(Profile::FromBrowserContext(context)) {
-  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+    : browser_context_(context) {
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
       this, bluetooth::OnAdapterStateChanged::kEventName);
 }
 
 BluetoothAPI::~BluetoothAPI() {
 }
 
 ExtensionBluetoothEventRouter* BluetoothAPI::bluetooth_event_router() {
   if (!bluetooth_event_router_)
-    bluetooth_event_router_.reset(new ExtensionBluetoothEventRouter(profile_));
+    bluetooth_event_router_.reset(
+        new ExtensionBluetoothEventRouter(browser_context_));
 
   return bluetooth_event_router_.get();
 }
 
 void BluetoothAPI::Shutdown() {
-  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
+      this);
 }
 
 void BluetoothAPI::OnListenerAdded(const EventListenerInfo& details) {
   if (bluetooth_event_router()->IsBluetoothSupported())
     bluetooth_event_router()->OnListenerAdded();
 }
 
 void BluetoothAPI::OnListenerRemoved(const EventListenerInfo& details) {
   if (bluetooth_event_router()->IsBluetoothSupported())
     bluetooth_event_router()->OnListenerRemoved();
@@ skipping 14 matching lines @@
   }
 
   BluetoothPermissionRequest param(params->profile.uuid);
   if (!BluetoothManifestData::CheckRequest(GetExtension(), param)) {
     error_ = kPermissionDenied;
     return false;
   }
 
   uuid_ = device::bluetooth_utils::CanonicalUuid(params->profile.uuid);
 
-  if (GetEventRouter(GetProfile())->HasProfile(uuid_)) {
+  if (GetEventRouter(browser_context())->HasProfile(uuid_)) {
     SetError(kProfileAlreadyRegistered);
     return false;
   }
 
   BluetoothProfile::Options options;
   if (params->profile.name.get())
     options.name = *params->profile.name.get();
   if (params->profile.channel.get())
     options.channel = *params->profile.channel.get();
   if (params->profile.psm.get())
@@ skipping 27 matching lines @@
 }
 
 void BluetoothAddProfileFunction::OnProfileRegistered(
     BluetoothProfile* bluetooth_profile) {
   if (!bluetooth_profile) {
     SetError(kProfileRegistrationFailed);
     SendResponse(false);
     return;
   }
 
-  if (GetEventRouter(GetProfile())->HasProfile(uuid_)) {
+  if (GetEventRouter(browser_context())->HasProfile(uuid_)) {
     bluetooth_profile->Unregister();
     SetError(kProfileAlreadyRegistered);
     SendResponse(false);
     return;
   }
 
   bluetooth_profile->SetConnectionCallback(
       base::Bind(&ExtensionBluetoothEventRouter::DispatchConnectionEvent,
-                 base::Unretained(GetEventRouter(GetProfile())),
+                 base::Unretained(GetEventRouter(browser_context())),
                  extension_id(),
                  uuid_));
-  GetEventRouter(GetProfile())->AddProfile(
-      uuid_, extension_id(), bluetooth_profile);
+  GetEventRouter(browser_context())
+      ->AddProfile(uuid_, extension_id(), bluetooth_profile);
   SendResponse(true);
 }
 
 bool BluetoothRemoveProfileFunction::RunImpl() {
   scoped_ptr<RemoveProfile::Params> params(
       RemoveProfile::Params::Create(*args_));
 
   if (!BluetoothDevice::IsUUIDValid(params->profile.uuid)) {
     SetError(kInvalidUuid);
     return false;
   }
 
   std::string uuid =
       device::bluetooth_utils::CanonicalUuid(params->profile.uuid);
 
-  if (!GetEventRouter(GetProfile())->HasProfile(uuid)) {
+  if (!GetEventRouter(browser_context())->HasProfile(uuid)) {
     SetError(kProfileNotFound);
     return false;
   }
 
-  GetEventRouter(GetProfile())->RemoveProfile(uuid);
+  GetEventRouter(browser_context())->RemoveProfile(uuid);
   return true;
 }
 
 // TODO(youngki): Implement.
 bool BluetoothGetProfilesFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<GetProfiles::Params> params(GetProfiles::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::GetProfilesOptions& options = params->options;
 
@@ skipping 30 matching lines @@
   return true;
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : device_events_sent_(0) {}
 
 void BluetoothGetDevicesFunction::DispatchDeviceSearchResult(
     const BluetoothDevice& device) {
   bluetooth::Device extension_device;
   bluetooth::BluetoothDeviceToApiDevice(device, &extension_device);
-  GetEventRouter(GetProfile())->DispatchDeviceEvent(
+  GetEventRouter(browser_context())->DispatchDeviceEvent(
       extensions::event_names::kBluetoothOnDeviceSearchResult,
       extension_device);
 
   device_events_sent_++;
 }
 
 void BluetoothGetDevicesFunction::FinishDeviceSearch() {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue());
   info->SetInteger("expectedEventCount", device_events_sent_);
   args->Append(info.release());
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kBluetoothOnDeviceSearchFinished, args.Pass()));
-  extensions::ExtensionSystem::Get(GetProfile())
+  extensions::ExtensionSystem::Get(browser_context())
       ->event_router()
       ->BroadcastEvent(event.Pass());
 
   SendResponse(true);
 }
 
 bool BluetoothGetDevicesFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
@@ skipping 97 matching lines @@
   if (!device) {
     SetError(kInvalidDevice);
     SendResponse(false);
     return false;
   }
 
   std::string uuid = device::bluetooth_utils::CanonicalUuid(
       options.profile.uuid);
 
   BluetoothProfile* bluetooth_profile =
-      GetEventRouter(GetProfile())->GetProfile(uuid);
+      GetEventRouter(browser_context())->GetProfile(uuid);
   if (!bluetooth_profile) {
     SetError(kProfileNotFound);
     SendResponse(false);
     return false;
   }
 
   device->ConnectToProfile(
       bluetooth_profile,
       base::Bind(&BluetoothConnectFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothConnectFunction::OnErrorCallback, this));
 
   return true;
 }
 
 bool BluetoothDisconnectFunction::RunImpl() {
   scoped_ptr<Disconnect::Params> params(Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::DisconnectOptions& options = params->options;
-  return GetEventRouter(GetProfile())->ReleaseSocket(options.socket.id);
+  return GetEventRouter(browser_context())->ReleaseSocket(options.socket.id);
 }
 
 BluetoothReadFunction::BluetoothReadFunction() : success_(false) {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 bool BluetoothReadFunction::Prepare() {
   scoped_ptr<Read::Params> params(Read::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::ReadOptions& options = params->options;
 
-  socket_ = GetEventRouter(GetProfile())->GetSocket(options.socket.id);
+  socket_ = GetEventRouter(browser_context())->GetSocket(options.socket.id);
   if (socket_.get() == NULL) {
     SetError(kSocketNotFoundError);
     return false;
   }
 
   success_ = false;
   return true;
 }
 
 void BluetoothReadFunction::Work() {
@@ skipping 27 matching lines @@
   // support is added
   base::DictionaryValue* options;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
 
   base::DictionaryValue* socket;
   EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("socket", &socket));
 
   int socket_id;
   EXTENSION_FUNCTION_VALIDATE(socket->GetInteger("id", &socket_id));
 
-  socket_ = GetEventRouter(GetProfile())->GetSocket(socket_id);
+  socket_ = GetEventRouter(browser_context())->GetSocket(socket_id);
   if (socket_.get() == NULL) {
     SetError(kSocketNotFoundError);
     return false;
   }
 
   base::BinaryValue* tmp_data;
   EXTENSION_FUNCTION_VALIDATE(options->GetBinary("data", &tmp_data));
   data_to_write_ = tmp_data;
 
   success_ = false;
@@ skipping 125 matching lines @@
 
   return true;
 }
 
 void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
   SetError(kStartDiscoveryFailed);
-  GetEventRouter(GetProfile())->SetResponsibleForDiscovery(false);
+  GetEventRouter(browser_context())->SetResponsibleForDiscovery(false);
   SendResponse(false);
-  GetEventRouter(GetProfile())->OnListenerRemoved();
+  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStartDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  GetEventRouter(GetProfile())->SetSendDiscoveryEvents(true);
+  GetEventRouter(browser_context())->SetSendDiscoveryEvents(true);
 
   // If this profile is already discovering devices, there should be nothing
   // else to do.
-  if (!GetEventRouter(GetProfile())->IsResponsibleForDiscovery()) {
-    GetEventRouter(GetProfile())->SetResponsibleForDiscovery(true);
-    GetEventRouter(GetProfile())->OnListenerAdded();
+  if (!GetEventRouter(browser_context())->IsResponsibleForDiscovery()) {
+    GetEventRouter(browser_context())->SetResponsibleForDiscovery(true);
+    GetEventRouter(browser_context())->OnListenerAdded();
     adapter->StartDiscovering(
         base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
         base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
   }
 
   return true;
 }
 
 void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
-  GetEventRouter(GetProfile())->OnListenerRemoved();
+  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 void BluetoothStopDiscoveryFunction::OnErrorCallback() {
   SetError(kStopDiscoveryFailed);
-  GetEventRouter(GetProfile())->SetResponsibleForDiscovery(true);
+  GetEventRouter(browser_context())->SetResponsibleForDiscovery(true);
   SendResponse(false);
-  GetEventRouter(GetProfile())->OnListenerRemoved();
+  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStopDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  GetEventRouter(GetProfile())->SetSendDiscoveryEvents(false);
-  if (GetEventRouter(GetProfile())->IsResponsibleForDiscovery()) {
+  GetEventRouter(browser_context())->SetSendDiscoveryEvents(false);
+  if (GetEventRouter(browser_context())->IsResponsibleForDiscovery()) {
     adapter->StopDiscovering(
         base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
         base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
   }
 
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions