Move chrome.bluetoothLowEnergy out of //chrome.

extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_api.cc

 // Copyright 2014 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_low_energy/bluetooth_low_energy_api.h"
+#include "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_forward.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/api/bluetooth_low_energy/utils.h"
-#include "chrome/common/extensions/api/bluetooth_low_energy.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_local_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
+#include "extensions/browser/api/bluetooth_low_energy/utils.h"
+#include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/kiosk/kiosk_delegate.h"
 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
+#include "extensions/common/api/bluetooth_low_energy.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/extension_id.h"
 #include "extensions/common/switches.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
-#endif
-
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace apibtle = extensions::api::bluetooth_low_energy;
 
 namespace extensions {
 
 namespace {
 
 const char kErrorAdapterNotInitialized[] =
@@ skipping 274 matching lines @@
           api_permissions,
           apibtle::DESCRIPTOR_PERMISSION_ENCRYPTEDAUTHENTICATEDWRITE)) {
     permissions |= device::BluetoothGattCharacteristic::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
   }
 
   return permissions;
 }
 
 bool IsAutoLaunchedKioskApp(const ExtensionId& id) {
-#if defined(OS_CHROMEOS)
-  chromeos::KioskAppManager::App app_info;
-  return chromeos::KioskAppManager::Get()->GetApp(id, &app_info) &&
-         app_info.was_auto_launched_with_zero_delay;
-#else
-  return false;
-#endif
+  KioskDelegate* delegate = ExtensionsAPIClient::Get()->GetKioskDelegate();
+  DCHECK(delegate);
+  return delegate->IsAutoLaunchedKioskApp(id);
 }
 
 bool IsPeripheralFlagEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBLEAdvertising);
 }
 
 }  // namespace
 
-
-static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI> >
+static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI>>
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI>*
 BluetoothLowEnergyAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 BluetoothLowEnergyAPI* BluetoothLowEnergyAPI::Get(BrowserContext* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return GetFactoryInstance()->Get(context);
 }
 
 BluetoothLowEnergyAPI::BluetoothLowEnergyAPI(BrowserContext* context)
     : event_router_(new BluetoothLowEnergyEventRouter(context)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
-BluetoothLowEnergyAPI::~BluetoothLowEnergyAPI() {
-}
+BluetoothLowEnergyAPI::~BluetoothLowEnergyAPI() {}
 
 void BluetoothLowEnergyAPI::Shutdown() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 namespace api {
 
 BluetoothLowEnergyExtensionFunctionDeprecated::
     BluetoothLowEnergyExtensionFunctionDeprecated() {}
 
@@ skipping 109 matching lines @@
   std::unique_ptr<apibtle::Connect::Params> params(
       apibtle::Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::ConnectProperties* properties = params->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->Connect(
-      persistent,
-      extension(),
-      params->device_address,
+      persistent, extension(), params->device_address,
       base::Bind(&BluetoothLowEnergyConnectFunction::SuccessCallback, this),
       base::Bind(&BluetoothLowEnergyConnectFunction::ErrorCallback, this));
 
   return true;
 }
 
 void BluetoothLowEnergyConnectFunction::SuccessCallback() {
   SendResponse(true);
 }
 
@@ skipping 15 matching lines @@
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::Disconnect::Params> params(
       apibtle::Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->Disconnect(
-      extension(),
-      params->device_address,
+      extension(), params->device_address,
       base::Bind(&BluetoothLowEnergyDisconnectFunction::SuccessCallback, this),
       base::Bind(&BluetoothLowEnergyDisconnectFunction::ErrorCallback, this));
 
   return true;
 }
 
 void BluetoothLowEnergyDisconnectFunction::SuccessCallback() {
   SendResponse(true);
 }
 
@@ skipping 80 matching lines @@
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::GetCharacteristic::Params> params(
       apibtle::GetCharacteristic::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Characteristic characteristic;
   BluetoothLowEnergyEventRouter::Status status =
-      event_router->GetCharacteristic(
-          extension(), params->characteristic_id, &characteristic);
+      event_router->GetCharacteristic(extension(), params->characteristic_id,
+                                      &characteristic);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristic::Result::Create as it doesn't convert lists of
   // enums correctly.
   SetResult(apibtle::CharacteristicToValue(&characteristic));
@@ skipping 15 matching lines @@
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::GetCharacteristics::Params> params(
       apibtle::GetCharacteristics::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::CharacteristicList characteristic_list;
   BluetoothLowEnergyEventRouter::Status status =
-      event_router->GetCharacteristics(
-          extension(), params->service_id, &characteristic_list);
+      event_router->GetCharacteristics(extension(), params->service_id,
+                                       &characteristic_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristics::Result::Create as it doesn't convert lists of
   // enums correctly.
   std::unique_ptr<base::ListValue> result(new base::ListValue());
@@ skipping 128 matching lines @@
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::ReadCharacteristicValue::Params> params(
       apibtle::ReadCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->characteristic_id;
   event_router->ReadCharacteristicValue(
-      extension(),
-      instance_id_,
+      extension(), instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback,
           this),
       base::Bind(
           &BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback,
           this));
 
   return true;
 }
 
@@ skipping 36 matching lines @@
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::WriteCharacteristicValue::Params> params(
       apibtle::WriteCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteCharacteristicValue(
-      extension(),
-      params->characteristic_id,
-      value,
+      extension(), params->characteristic_id, value,
       base::Bind(
           &BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback,
           this),
       base::Bind(
           &BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback,
           this));
 
   return true;
 }
 
@@ skipping 25 matching lines @@
   std::unique_ptr<apibtle::StartCharacteristicNotifications::Params> params(
       apibtle::StartCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::NotificationProperties* properties = params->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->StartCharacteristicNotifications(
-      persistent,
-      extension(),
-      params->characteristic_id,
+      persistent, extension(), params->characteristic_id,
       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
                      SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
                      ErrorCallback,
                  this));
 
   return true;
 }
 
-void
-BluetoothLowEnergyStartCharacteristicNotificationsFunction::SuccessCallback() {
+void BluetoothLowEnergyStartCharacteristicNotificationsFunction::
+    SuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothLowEnergyStartCharacteristicNotificationsFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
   SetError(StatusToString(status));
   SendResponse(false);
 }
 
 bool BluetoothLowEnergyStopCharacteristicNotificationsFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::StopCharacteristicNotifications::Params> params(
       apibtle::StopCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->StopCharacteristicNotifications(
-      extension(),
-      params->characteristic_id,
+      extension(), params->characteristic_id,
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
                      SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
                      ErrorCallback,
                  this));
 
   return true;
 }
 
-void
-BluetoothLowEnergyStopCharacteristicNotificationsFunction::SuccessCallback() {
+void BluetoothLowEnergyStopCharacteristicNotificationsFunction::
+    SuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothLowEnergyStopCharacteristicNotificationsFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
   SetError(StatusToString(status));
   SendResponse(false);
 }
 
 bool BluetoothLowEnergyReadDescriptorValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::ReadDescriptorValue::Params> params(
       apibtle::ReadDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->descriptor_id;
   event_router->ReadDescriptorValue(
-      extension(),
-      instance_id_,
+      extension(), instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
           this),
       base::Bind(&BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback,
                  this));
 
   return true;
 }
 
 void BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback() {
@@ skipping 35 matching lines @@
     SendResponse(false);
     return false;
   }
 
   std::unique_ptr<apibtle::WriteDescriptorValue::Params> params(
       apibtle::WriteDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteDescriptorValue(
-      extension(),
-      params->descriptor_id,
-      value,
+      extension(), params->descriptor_id, value,
       base::Bind(
           &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
           this),
       base::Bind(&BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback,
                  this));
 
   return true;
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback() {
   results_ = apibtle::WriteDescriptorValue::Results::Create();
   SendResponse(true);
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
   SetError(StatusToString(status));
   SendResponse(false);
 }
 
 BluetoothLowEnergyAdvertisementFunction::
     BluetoothLowEnergyAdvertisementFunction()
-    : advertisements_manager_(nullptr) {
-}
+    : advertisements_manager_(nullptr) {}
 
 BluetoothLowEnergyAdvertisementFunction::
-    ~BluetoothLowEnergyAdvertisementFunction() {
-}
+    ~BluetoothLowEnergyAdvertisementFunction() {}
 
 int BluetoothLowEnergyAdvertisementFunction::AddAdvertisement(
     BluetoothApiAdvertisement* advertisement) {
   DCHECK(advertisements_manager_);
   return advertisements_manager_->Add(advertisement);
 }
 
 BluetoothApiAdvertisement*
 BluetoothLowEnergyAdvertisementFunction::GetAdvertisement(
     int advertisement_id) {
@@ skipping 414 matching lines @@
                         params_->response.value->end());
   }
   event_router_->HandleRequestResponse(
       extension(), params_->response.request_id, params_->response.is_error,
       uint8_vector);
   Respond(NoArguments());
 }
 
 }  // namespace api
 }  // namespace extensions