Change getDevices to use a DeviceCallback.

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"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
 #include <string>
 
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
+#include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/experimental_bluetooth.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/memory/ref_counted.h"
 #include "base/safe_strerror_posix.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
@@ skipping 68 matching lines @@
 }
 
 bool BluetoothGetNameFunction::RunImpl() {
   SetResult(Value::CreateStringValue(GetAdapter(profile()).name()));
   return true;
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0) {}
 
-void BluetoothGetDevicesFunction::AddDeviceIfTrueCallback(
-    ListValue* list,
+void BluetoothGetDevicesFunction::DispatchDeviceSearchResult(
+    const chromeos::BluetoothDevice& device) {
+  experimental_bluetooth::Device extension_device;
+  experimental_bluetooth::BluetoothDeviceToApiDevice(device, &extension_device);
+  GetEventRouter(profile())->DispatchDeviceEvent(
+      extensions::event_names::kBluetoothOnDeviceSearchResult,
+      extension_device);
+}
+
+void BluetoothGetDevicesFunction::ProvidesServiceCallback(
     const chromeos::BluetoothDevice* device,
-    bool shouldAdd) {
+    bool providesService) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  if (shouldAdd)
-    list->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
+  CHECK(device);
+  if (providesService)
+    DispatchDeviceSearchResult(*device);
 
   callbacks_pending_--;
   if (callbacks_pending_ == -1)
     SendResponse(true);
 }
 
 bool BluetoothGetDevicesFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::GetDevicesOptions& options = params->options;
 
   std::string uuid;
   if (options.uuid.get() != NULL) {
     uuid = chromeos::bluetooth_utils::CanonicalUuid(*options.uuid.get());
     if (uuid.empty()) {
       SetError(kInvalidUuid);
       return false;
     }
   }
 
-  ListValue* matches = new ListValue;
-  SetResult(matches);
-
   CHECK_EQ(0, callbacks_pending_);
 
   chromeos::BluetoothAdapter::DeviceList devices =
       GetMutableAdapter(profile())->GetDevices();
   for (chromeos::BluetoothAdapter::DeviceList::iterator i = devices.begin();
       i != devices.end(); ++i) {
     chromeos::BluetoothDevice* device = *i;
+    CHECK(device);
 
     if (!uuid.empty() && !(device->ProvidesServiceWithUUID(uuid)))
       continue;
 
     if (options.name.get() == NULL) {
-      matches->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
+      DispatchDeviceSearchResult(*device);
       continue;
     }
 
     callbacks_pending_++;
     device->ProvidesServiceWithName(
         *(options.name),
-        base::Bind(&BluetoothGetDevicesFunction::AddDeviceIfTrueCallback,
+        base::Bind(&BluetoothGetDevicesFunction::ProvidesServiceCallback,
                    this,
-                   matches,
                    device));
   }
   callbacks_pending_--;
 
   // The count is checked for -1 because of the extra decrement after the
   // for-loop, which ensures that all requests have been made before
   // SendResponse happens.
   if (callbacks_pending_ == -1)
     SendResponse(true);
 
@@ skipping 434 matching lines @@
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 }  // namespace api
 }  // namespace extensions