Pull AsyncApiFunction out of src/chrome

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.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_event_router.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/event_names.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/bluetooth.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
 
 namespace extensions {
 
 namespace bluetooth = api::bluetooth;
 
 // A struct storing a Bluetooth socket and the extension that added it.
 struct ExtensionBluetoothSocketRecord {
   std::string extension_id;
   scoped_refptr<device::BluetoothSocket> socket;
 };
 
 // A struct storing a Bluetooth profile and the extension that added it.
 struct ExtensionBluetoothProfileRecord {
   std::string extension_id;
   device::BluetoothProfile* profile;
 };
 
-ExtensionBluetoothEventRouter::ExtensionBluetoothEventRouter(Profile* profile)
+ExtensionBluetoothEventRouter::ExtensionBluetoothEventRouter(

[James Cook, 2014/02/26 17:57:21]

These conversions seem awfully familiar, and similar to what yoz is doing in
https://codereview.chromium.org/179243002/

Are you up to date with his latest Profile -> BrowserContext conversions?

[Ken Rockot(use gerrit already), 2014/02/26 18:20:44]

Adding yoz to take a look. I see some conflict, but no duplicate effort. He's
adding profile.h to this impls so they can pass Profiles as BrowserContexts,
whereas I'm changing the call sites to pass browser_context() instead of
GetProfile().

I can wait until https://codereview.chromium.org/179243002 lands, clean this up,
and then land it.

[Yoyo Zhou, 2014/02/27 00:08:52]

https://codereview.chromium.org/168253002/ does conflict with some of the stuff
in this CL, though not this one. You'd have to look on a file-by-file basis to
make sure which, I'm afraid.

+    content::BrowserContext* context)
     : send_discovery_events_(false),
       responsible_for_discovery_(false),
-      profile_(profile),
+      browser_context_(context),
       adapter_(NULL),
       num_event_listeners_(0),
       next_socket_id_(1),
       weak_ptr_factory_(this) {
-  DCHECK(profile_);
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(profile_));
+  DCHECK(browser_context_);
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<content::BrowserContext>(browser_context_));
 }
 
 ExtensionBluetoothEventRouter::~ExtensionBluetoothEventRouter() {
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
   DLOG_IF(WARNING, socket_map_.size() != 0)
       << "Bluetooth sockets are still open.";
   socket_map_.clear();
@@ skipping 114 matching lines @@
   }
 
   send_discovery_events_ = should_send;
 }
 
 void ExtensionBluetoothEventRouter::DispatchDeviceEvent(
     const std::string& event_name, const bluetooth::Device& device) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(device.ToValue().release());
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
-  ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
+  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
+      event.Pass());
 }
 
 void ExtensionBluetoothEventRouter::DispatchConnectionEvent(
     const std::string& extension_id,
     const std::string& uuid,
     const device::BluetoothDevice* device,
     scoped_refptr<device::BluetoothSocket> socket) {
   if (!HasProfile(uuid))
     return;
 
   int socket_id = RegisterSocket(extension_id, socket);
   api::bluetooth::Socket result_socket;
   api::bluetooth::BluetoothDeviceToApiDevice(*device, &result_socket.device);
   result_socket.profile.uuid = uuid;
   result_socket.id = socket_id;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(result_socket.ToValue().release());
   scoped_ptr<Event> event(new Event(
       bluetooth::OnConnection::kEventName, args.Pass()));
-  ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
-      extension_id, event.Pass());
+  ExtensionSystem::Get(browser_context_)
+      ->event_router()
+      ->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void ExtensionBluetoothEventRouter::AdapterPresentChanged(
     device::BluetoothAdapter* adapter, bool present) {
   if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
   DispatchAdapterStateEvent();
 }
@@ skipping 68 matching lines @@
 
 void ExtensionBluetoothEventRouter::DispatchAdapterStateEvent() {
   api::bluetooth::AdapterState state;
   PopulateAdapterState(*adapter_.get(), &state);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(state.ToValue().release());
   scoped_ptr<Event> event(new Event(
       bluetooth::OnAdapterStateChanged::kEventName,
       args.Pass()));
-  ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
+  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
+      event.Pass());
 }
 
 void ExtensionBluetoothEventRouter::CleanUpForExtension(
     const std::string& extension_id) {
   // Remove all profiles added by the extension.
   BluetoothProfileMap::iterator profile_iter = bluetooth_profile_map_.begin();
   while (profile_iter != bluetooth_profile_map_.end()) {
     ExtensionBluetoothProfileRecord record = profile_iter->second;
     if (record.extension_id == extension_id) {
       bluetooth_profile_map_.erase(profile_iter++);
@@ skipping 23 matching lines @@
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       extensions::UnloadedExtensionInfo* info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       CleanUpForExtension(info->extension->id());
       break;
     }
   }
 }
 
 }  // namespace extensions