MD Settings: Bluetooth: Fix adapter state and discovery

extensions/browser/api/bluetooth/bluetooth_private_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 "extensions/browser/api/bluetooth/bluetooth_private_api.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
+#include "components/device_event_log/device_event_log.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "extensions/browser/api/bluetooth/bluetooth_api.h"
 #include "extensions/browser/api/bluetooth/bluetooth_api_pairing_delegate.h"
 #include "extensions/browser/api/bluetooth/bluetooth_event_router.h"
 #include "extensions/common/api/bluetooth_private.h"
 
 namespace bt_private = extensions::api::bluetooth_private;
@@ skipping 130 matching lines @@
   }
 
   const bt_private::NewAdapterState& new_state = params->adapter_state;
 
   // These properties are not owned.
   std::string* name = new_state.name.get();
   bool* powered = new_state.powered.get();
   bool* discoverable = new_state.discoverable.get();
 
   if (name && adapter->GetName() != *name) {
+    BLUETOOTH_LOG(USER) << "SetAdapterState: name=" << *name;
     pending_properties_.insert(kNameProperty);
     adapter->SetName(*name, CreatePropertySetCallback(kNameProperty),
                      CreatePropertyErrorCallback(kNameProperty));
   }
 
   if (powered && adapter->IsPowered() != *powered) {
+    BLUETOOTH_LOG(USER) << "SetAdapterState: powerd=" << *powered;
     pending_properties_.insert(kPoweredProperty);
     adapter->SetPowered(*powered, CreatePropertySetCallback(kPoweredProperty),
                         CreatePropertyErrorCallback(kPoweredProperty));
   }
 
   if (discoverable && adapter->IsDiscoverable() != *discoverable) {
+    BLUETOOTH_LOG(USER) << "SetAdapterState: discoverable=" << *discoverable;
     pending_properties_.insert(kDiscoverableProperty);
     adapter->SetDiscoverable(
         *discoverable, CreatePropertySetCallback(kDiscoverableProperty),
         CreatePropertyErrorCallback(kDiscoverableProperty));
   }
 
   parsed_ = true;
 
   if (pending_properties_.empty())
     SendResponse(true);
   return true;
 }
 
 base::Closure
 BluetoothPrivateSetAdapterStateFunction::CreatePropertySetCallback(
     const std::string& property_name) {
+  BLUETOOTH_LOG(DEBUG) << "Set property succeeded: " << property_name;
   return base::Bind(
       &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertySet, this,
       property_name);
 }
 
 base::Closure
 BluetoothPrivateSetAdapterStateFunction::CreatePropertyErrorCallback(
     const std::string& property_name) {
+  BLUETOOTH_LOG(DEBUG) << "Set property failed: " << property_name;
   return base::Bind(
       &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertyError, this,
       property_name);
 }
 
 void BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertySet(
     const std::string& property) {
   DCHECK(pending_properties_.find(property) != pending_properties_.end());
   DCHECK(failed_properties_.find(property) == failed_properties_.end());
 
@@ skipping 385 matching lines @@
     device::BluetoothDevice::ConnectErrorCode error) {
   SetError(kPairingFailed);
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace api
 
 }  // namespace extensions