D-Bus Clients for BlueZ 5 API

chromeos/dbus/experimental_bluetooth_agent_service_provider.cc

Index: chromeos/dbus/experimental_bluetooth_agent_service_provider.cc
diff --git a/chromeos/dbus/bluetooth_agent_service_provider.cc b/chromeos/dbus/experimental_bluetooth_agent_service_provider.cc
similarity index 57%
copy from chromeos/dbus/bluetooth_agent_service_provider.cc
copy to chromeos/dbus/experimental_bluetooth_agent_service_provider.cc
index 786935c25f38c393506d4db5393f5bc426d12014..0e77d77ee62d5dac60fd3364b98b1a0359365ca1 100644
--- a/chromeos/dbus/bluetooth_agent_service_provider.cc
+++ b/chromeos/dbus/experimental_bluetooth_agent_service_provider.cc
@@ -1,8 +1,8 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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 "chromeos/dbus/bluetooth_agent_service_provider.h"
+#include "chromeos/dbus/experimental_bluetooth_agent_service_provider.h"
 
 #include <string>
 
@@ -17,109 +17,120 @@
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-namespace {
-
-// Constants used by BlueZ for the ConfirmModeChange method.
-const char kModeOff[] = "off";
-const char kModeConnectable[] = "connectable";
-const char kModeDiscoverable[] = "discoverable";
-
-}  // namespace
-
 namespace chromeos {
 
-// The BluetoothAgentServiceProvider implementation used in production.
-class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
+// The ExperimentalBluetoothAgentServiceProvider implementation used in
+// production.
+class ExperimentalBluetoothAgentServiceProviderImpl
+    : public ExperimentalBluetoothAgentServiceProvider {
  public:
-  BluetoothAgentServiceProviderImpl(dbus::Bus* bus,
-                                    const dbus::ObjectPath& object_path,
-                                    Delegate* delegate)
+  ExperimentalBluetoothAgentServiceProviderImpl(
+      dbus::Bus* bus,
+      const dbus::ObjectPath& object_path,
+      Delegate* delegate)
       : origin_thread_id_(base::PlatformThread::CurrentId()),
         bus_(bus),
         delegate_(delegate),
         object_path_(object_path),
         weak_ptr_factory_(this) {
-    VLOG(1) << "Creating BluetoothAdapterClientImpl for "
-            << object_path.value();
+    VLOG(1) << "Creating Bluetooth Agent: " << object_path_.value();
 
     exported_object_ = bus_->GetExportedObject(object_path_);
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
         bluetooth_agent::kRelease,
-        base::Bind(&BluetoothAgentServiceProviderImpl::Release,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::ReleaseExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::Release,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
         bluetooth_agent::kRequestPinCode,
-        base::Bind(&BluetoothAgentServiceProviderImpl::RequestPinCode,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::RequestPinCodeExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::RequestPinCode,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
-        bluetooth_agent::kRequestPasskey,
-        base::Bind(&BluetoothAgentServiceProviderImpl::RequestPasskey,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::RequestPasskeyExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
+        bluetooth_agent::kDisplayPinCode,
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::DisplayPinCode,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
-        bluetooth_agent::kDisplayPinCode,
-        base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPinCode,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPinCodeExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
+        bluetooth_agent::kRequestPasskey,
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::RequestPasskey,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
         bluetooth_agent::kDisplayPasskey,
-        base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPasskey,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPasskeyExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::DisplayPasskey,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
         bluetooth_agent::kRequestConfirmation,
-        base::Bind(&BluetoothAgentServiceProviderImpl::RequestConfirmation,
-                   weak_ptr_factory_.GetWeakPtr()),
         base::Bind(
-            &BluetoothAgentServiceProviderImpl::RequestConfirmationExported,
+            &ExperimentalBluetoothAgentServiceProviderImpl::RequestConfirmation,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
             weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
-        bluetooth_agent::kAuthorize,
-        base::Bind(&BluetoothAgentServiceProviderImpl::Authorize,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::AuthorizeExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
+        bluetooth_agent::kRequestAuthorization,
+        base::Bind(
+           &ExperimentalBluetoothAgentServiceProviderImpl::RequestAuthorization,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
-        bluetooth_agent::kConfirmModeChange,
-        base::Bind(&BluetoothAgentServiceProviderImpl::ConfirmModeChange,
-                   weak_ptr_factory_.GetWeakPtr()),
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
+        bluetooth_agent::kAuthorizeService,
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::AuthorizeService,
+            weak_ptr_factory_.GetWeakPtr()),
         base::Bind(
-            &BluetoothAgentServiceProviderImpl::ConfirmModeChangeExported,
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
             weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        bluetooth_agent::kBluetoothAgentInterface,
+        bluetooth_agent::kExperimentalBluetoothAgentInterface,
         bluetooth_agent::kCancel,
-        base::Bind(&BluetoothAgentServiceProviderImpl::Cancel,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothAgentServiceProviderImpl::CancelExported,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::Cancel,
+            weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(
+            &ExperimentalBluetoothAgentServiceProviderImpl::OnExported,
+            weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual ~BluetoothAgentServiceProviderImpl() {
+  virtual ~ExperimentalBluetoothAgentServiceProviderImpl() {
+    VLOG(1) << "Cleaning up Bluetooth Agent: " << object_path_.value();
+
     // Unregister the object path so we can reuse with a new agent.
     bus_->UnregisterExportedObject(object_path_);
   }
@@ -142,14 +153,6 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
-  // Called by dbus:: when the Release method is exported.
-  void ReleaseExported(const std::string& interface_name,
-                       const std::string& method_name,
-                       bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
-  }
-
   // Called by dbus:: when the Bluetooth daemon requires a PIN Code for
   // device authentication.
   void RequestPinCode(dbus::MethodCall* method_call,
@@ -166,7 +169,7 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     }
 
     Delegate::PinCodeCallback callback = base::Bind(
-        &BluetoothAgentServiceProviderImpl::OnPinCode,
+        &ExperimentalBluetoothAgentServiceProviderImpl::OnPinCode,
         weak_ptr_factory_.GetWeakPtr(),
         method_call,
         response_sender);
@@ -174,75 +177,51 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     delegate_->RequestPinCode(device_path, callback);
   }
 
-  // Called by dbus:: when the RequestPinCode method is exported.
-  void RequestPinCodeExported(const std::string& interface_name,
-                              const std::string& method_name,
-                              bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
-  }
-
-  // Called by dbus:: when the Bluetooth daemon requires a Passkey for
-  // device authentication.
-  void RequestPasskey(dbus::MethodCall* method_call,
+  // Called by dbus:: when the Bluetooth daemon requires that the user
+  // enter a PIN Code into the remote device so that it may be
+  // authenticated.
+  void DisplayPinCode(dbus::MethodCall* method_call,
                       dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath device_path;
-    if (!reader.PopObjectPath(&device_path)) {
-      LOG(WARNING) << "RequestPasskey called with incorrect paramters: "
+    std::string pincode;
+    if (!reader.PopObjectPath(&device_path) ||
+        !reader.PopString(&pincode)) {
+      LOG(WARNING) << "DisplayPinCode called with incorrect paramters: "
                    << method_call->ToString();
       return;
     }
 
-    Delegate::PasskeyCallback callback = base::Bind(
-        &BluetoothAgentServiceProviderImpl::OnPasskey,
-        weak_ptr_factory_.GetWeakPtr(),
-        method_call,
-        response_sender);
-
-    delegate_->RequestPasskey(device_path, callback);
-  }
+    delegate_->DisplayPinCode(device_path, pincode);
 
-  // Called by dbus:: when the RequestPasskey method is exported.
-  void RequestPasskeyExported(const std::string& interface_name,
-                              const std::string& method_name,
-                              bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
-  // Called by dbus:: when the Bluetooth daemon requires that the user
-  // enter a PIN Code into the remote device so that it may be
-  // authenticated.
-  void DisplayPinCode(dbus::MethodCall* method_call,
+  // Called by dbus:: when the Bluetooth daemon requires a Passkey for
+  // device authentication.
+  void RequestPasskey(dbus::MethodCall* method_call,
                       dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath device_path;
-    std::string pincode;
-    if (!reader.PopObjectPath(&device_path) ||
-        !reader.PopString(&pincode)) {
-      LOG(WARNING) << "DisplayPinCode called with incorrect paramters: "
+    if (!reader.PopObjectPath(&device_path)) {
+      LOG(WARNING) << "RequestPasskey called with incorrect paramters: "
                    << method_call->ToString();
       return;
     }
 
-    delegate_->DisplayPinCode(device_path, pincode);
-
-    response_sender.Run(dbus::Response::FromMethodCall(method_call));
-  }
+    Delegate::PasskeyCallback callback = base::Bind(
+        &ExperimentalBluetoothAgentServiceProviderImpl::OnPasskey,
+        weak_ptr_factory_.GetWeakPtr(),
+        method_call,
+        response_sender);
 
-  // Called by dbus:: when the DisplayPinCode method is exported.
-  void DisplayPinCodeExported(const std::string& interface_name,
-                              const std::string& method_name,
-                              bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    delegate_->RequestPasskey(device_path, callback);
   }
 
   // Called by dbus:: when the Bluetooth daemon requires that the user
@@ -256,6 +235,7 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath device_path;
     uint32 passkey;
+    int16 entered;

[satorux1, 2013/03/22 02:00:12]

more like a matter of taste: initialize them with 0? 

     if (!reader.PopObjectPath(&device_path) ||
         !reader.PopUint32(&passkey)) {
       LOG(WARNING) << "DisplayPasskey called with incorrect paramters: "
@@ -263,17 +243,13 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
       return;
     }
 
-    delegate_->DisplayPasskey(device_path, passkey);
+    // This wasn't always provided, play it safe...
+    if (!reader.PopInt16(&entered))
+      entered = 0;
 
-    response_sender.Run(dbus::Response::FromMethodCall(method_call));
-  }
+    delegate_->DisplayPasskey(device_path, passkey, entered);
 
-  // Called by dbus:: when the DisplayPasskey method is exported.
-  void DisplayPasskeyExported(const std::string& interface_name,
-                              const std::string& method_name,
-                              bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by dbus:: when the Bluetooth daemon requires that the user
@@ -296,7 +272,7 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     }
 
     Delegate::ConfirmationCallback callback = base::Bind(
-        &BluetoothAgentServiceProviderImpl::OnConfirmation,
+        &ExperimentalBluetoothAgentServiceProviderImpl::OnConfirmation,
         weak_ptr_factory_.GetWeakPtr(),
         method_call,
         response_sender);
@@ -304,92 +280,56 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     delegate_->RequestConfirmation(device_path, passkey, callback);
   }
 
-  // Called by dbus:: when the RequestConfirmation method is exported.
-  void RequestConfirmationExported(const std::string& interface_name,
-                                   const std::string& method_name,
-                                   bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
-  }
-
   // Called by dbus:: when the Bluetooth daemon requires that the user
-  // confirm that that a remote device is authorized to connect to a service
-  // UUID.
-  void Authorize(dbus::MethodCall* method_call,
-                 dbus::ExportedObject::ResponseSender response_sender) {
+  // confirm an incoming just-works pairing.
+  void RequestAuthorization(
+        dbus::MethodCall* method_call,
+        dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath device_path;
-    std::string uuid;
-    if (!reader.PopObjectPath(&device_path) ||
-        !reader.PopString(&uuid)) {
-      LOG(WARNING) << "Authorize called with incorrect paramters: "
+    if (!reader.PopObjectPath(&device_path)) {
+      LOG(WARNING) << "RequestAuthorization called with incorrect paramters: "
                    << method_call->ToString();
       return;
     }
 
     Delegate::ConfirmationCallback callback = base::Bind(
-        &BluetoothAgentServiceProviderImpl::OnConfirmation,
+        &ExperimentalBluetoothAgentServiceProviderImpl::OnConfirmation,
         weak_ptr_factory_.GetWeakPtr(),
         method_call,
         response_sender);
 
-    delegate_->Authorize(device_path, uuid, callback);
-  }
-
-  // Called by dbus:: when the Authorize method is exported.
-  void AuthorizeExported(const std::string& interface_name,
-                         const std::string& method_name,
-                         bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    delegate_->RequestAuthorization(device_path, callback);
   }
 
   // Called by dbus:: when the Bluetooth daemon requires that the user
-  // confirm that the adapter may change mode.
-  void ConfirmModeChange(dbus::MethodCall* method_call,
-                         dbus::ExportedObject::ResponseSender response_sender) {
+  // confirm that that a remote device is authorized to connect to a service
+  // UUID.
+  void AuthorizeService(dbus::MethodCall* method_call,
+                        dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
-    std::string mode_str;
-    if (!reader.PopString(&mode_str)) {
-      LOG(WARNING) << "ConfirmModeChange called with incorrect paramters: "
+    dbus::ObjectPath device_path;
+    std::string uuid;
+    if (!reader.PopObjectPath(&device_path) ||
+        !reader.PopString(&uuid)) {
+      LOG(WARNING) << "AuthorizeService called with incorrect paramters: "
                    << method_call->ToString();
       return;
     }
 
-    Delegate::Mode mode;
-    if (mode_str == kModeOff) {
-      mode = Delegate::OFF;
-    } else if (mode_str == kModeConnectable) {
-      mode = Delegate::CONNECTABLE;
-    } else if (mode_str == kModeDiscoverable) {
-      mode = Delegate::DISCOVERABLE;
-    } else {
-      LOG(WARNING) << "ConfirmModeChange called with unknown mode: "
-                   << mode_str;
-      return;
-    }
-
     Delegate::ConfirmationCallback callback = base::Bind(
-        &BluetoothAgentServiceProviderImpl::OnConfirmation,
+        &ExperimentalBluetoothAgentServiceProviderImpl::OnConfirmation,
         weak_ptr_factory_.GetWeakPtr(),
         method_call,
         response_sender);
 
-    delegate_->ConfirmModeChange(mode, callback);
-  }
-
-  // Called by dbus:: when the ConfirmModeChange method is exported.
-  void ConfirmModeChangeExported(const std::string& interface_name,
-                                 const std::string& method_name,
-                                 bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    delegate_->AuthorizeService(device_path, uuid, callback);
   }
 
   // Called by dbus:: when the request failed before a reply was returned
@@ -404,10 +344,10 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
-  // Called by dbus:: when the Cancel method is exported.
-  void CancelExported(const std::string& interface_name,
-                      const std::string& method_name,
-                      bool success) {
+  // Called by dbus:: when a method is exported.
+  void OnExported(const std::string& interface_name,
+                  const std::string& method_name,
+                  bool success) {
     LOG_IF(WARNING, !success) << "Failed to export "
                               << interface_name << "." << method_name;
   }
@@ -535,38 +475,44 @@ class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
   // than we do.
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<BluetoothAgentServiceProviderImpl> weak_ptr_factory_;
+  base::WeakPtrFactory<ExperimentalBluetoothAgentServiceProviderImpl>
+      weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothAgentServiceProviderImpl);
+  DISALLOW_COPY_AND_ASSIGN(ExperimentalBluetoothAgentServiceProviderImpl);
 };
 
-// The BluetoothAgentServiceProvider implementation used on Linux desktop,
-// which does nothing.
-class BluetoothAgentServiceProviderStubImpl
-    : public BluetoothAgentServiceProvider {
+// The ExperimentalBluetoothAgentServiceProvider implementation used on Linux
+// desktop, which does nothing.
+class ExperimentalBluetoothAgentServiceProviderStubImpl
+    : public ExperimentalBluetoothAgentServiceProvider {
  public:
-  explicit BluetoothAgentServiceProviderStubImpl(Delegate* delegate_) {
+  explicit ExperimentalBluetoothAgentServiceProviderStubImpl(
+      Delegate* delegate) {
   }
 
-  virtual ~BluetoothAgentServiceProviderStubImpl() {
+  virtual ~ExperimentalBluetoothAgentServiceProviderStubImpl() {
   }
 };
 
-BluetoothAgentServiceProvider::BluetoothAgentServiceProvider() {
+ExperimentalBluetoothAgentServiceProvider::
+    ExperimentalBluetoothAgentServiceProvider() {
 }
 
-BluetoothAgentServiceProvider::~BluetoothAgentServiceProvider() {
+ExperimentalBluetoothAgentServiceProvider::
+    ~ExperimentalBluetoothAgentServiceProvider() {
 }
 
 // static
-BluetoothAgentServiceProvider* BluetoothAgentServiceProvider::Create(
-    dbus::Bus* bus,
-    const dbus::ObjectPath& object_path,
-    Delegate* delegate) {
+ExperimentalBluetoothAgentServiceProvider*
+    ExperimentalBluetoothAgentServiceProvider::Create(
+        dbus::Bus* bus,
+        const dbus::ObjectPath& object_path,
+        Delegate* delegate) {
   if (base::chromeos::IsRunningOnChromeOS()) {
-    return new BluetoothAgentServiceProviderImpl(bus, object_path, delegate);
+    return new ExperimentalBluetoothAgentServiceProviderImpl(
+        bus, object_path, delegate);
   } else {
-    return new BluetoothAgentServiceProviderStubImpl(delegate);
+    return new ExperimentalBluetoothAgentServiceProviderStubImpl(delegate);
   }
 }