Bluetooth Extension API: Add a discovery API

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 "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/experimental_bluetooth.h"
@@ skipping 28 matching lines @@
 }
 
 }  // namespace
 #endif
 
 namespace {
 
 const char kFailedToConnect[] = "Connection failed";
 const char kInvalidDevice[] = "Invalid device";
 const char kSocketNotFoundError[] = "Socket not found: invalid socket id";
+const char kStartDiscoveryFailed[] =
+    "Starting discovery failed, or already discovering";
+const char kStopDiscoveryFailed[] = "Failed to stop discovery";
 
 }  // namespace
 
 namespace Connect = extensions::api::experimental_bluetooth::Connect;
 namespace Disconnect = extensions::api::experimental_bluetooth::Disconnect;
 namespace GetDevicesWithServiceName =
     extensions::api::experimental_bluetooth::GetDevicesWithServiceName;
 namespace GetDevicesWithServiceUUID =
     extensions::api::experimental_bluetooth::GetDevicesWithServiceUUID;
 namespace Read = extensions::api::experimental_bluetooth::Read;
@@ skipping 236 matching lines @@
   }
 
   if (!success_)
     SetError(safe_strerror(errsv));
 }
 
 bool BluetoothWriteFunction::Respond() {
   return success_;
 }
 
+void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
+  SendResponse(true);
+  Release();  // Added in RunImpl
+}
+
+void BluetoothStartDiscoveryFunction::OnErrorCallback() {
+  SetError(kStartDiscoveryFailed);
+  SendResponse(false);
+  Release();  // Added in RunImpl
+}
+
+bool BluetoothStartDiscoveryFunction::RunImpl() {
+  GetEventRouter(profile())->SetSendDiscoveryEvents(true);
+
+  // BluetoothAdapter will throw an error if we SetDiscovering(true) when
+  // discovery is already in progress
+  if (GetMutableAdapter(profile())->IsDiscovering()) {
+    SendResponse(true);
+    return true;
+  }
+
+  GetMutableAdapter(profile())->SetDiscovering(true,
+      base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
+      base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
+  AddRef();  // Removed in whichever callback is called.
+  return true;
+}
+
+void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
+  SendResponse(true);
+  Release();  // Added in RunImpl
+}
+
+void BluetoothStopDiscoveryFunction::OnErrorCallback() {
+  SetError(kStopDiscoveryFailed);
+  SendResponse(false);
+  Release();  // Added in RunImpl
+}
+
+bool BluetoothStopDiscoveryFunction::RunImpl() {
+  GetEventRouter(profile())->SetSendDiscoveryEvents(false);
+  GetMutableAdapter(profile())->SetDiscovering(false,
+      base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
+      base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
+  AddRef();  // Removed in whichever callback is called.
+  return true;
+}
+
 #else
 
 // -----------------------------------------------------------------------------
 // NIY stubs
 // -----------------------------------------------------------------------------
 bool BluetoothIsAvailableFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
@@ skipping 44 matching lines @@
 }
 
 void BluetoothWriteFunction::Work() {
 }
 
 bool BluetoothWriteFunction::Respond() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
+bool BluetoothStartDiscoveryFunction::RunImpl() {
+  NOTREACHED() << "Not implemented yet";
+  return false;
+}
+
+bool BluetoothStopDiscoveryFunction::RunImpl() {
+  NOTREACHED() << "Not implemented yet";
+  return false;
+}
+
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 bool BluetoothSetOutOfBandPairingDataFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
 bool BluetoothGetOutOfBandPairingDataFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
 }  // namespace api
 }  // namespace extensions