chrome.bluetooth API improvements.

device/bluetooth/bluetooth_adapter_factory.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 "device/bluetooth/bluetooth_adapter_factory.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 
 #if defined(OS_CHROMEOS)
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #elif defined(OS_WIN)
 #include "device/bluetooth/bluetooth_adapter_win.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
 #endif
 
 namespace {
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 
+base::LazyInstance<BluetoothAdapterFactory> adapter_factory =
+    LAZY_INSTANCE_INITIALIZER;
+
 // Shared default adapter instance, we don't want to keep this class around
 // if nobody is using it so use a WeakPtr and create the object when needed;
 // since Google C++ Style (and clang's static analyzer) forbids us having
 // exit-time destructors we use a leaky lazy instance for it.
 base::LazyInstance<base::WeakPtr<device::BluetoothAdapter> >::Leaky
     default_adapter = LAZY_INSTANCE_INITIALIZER;
 
 typedef std::vector<BluetoothAdapterFactory::AdapterCallback>
     AdapterCallbackList;
 
@@ skipping 15 matching lines @@
   }
   adapter_callbacks.Get().clear();
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 namespace device {
 
 // static
+void BluetoothAdapterFactory::SetAdapterInitializer(
+    AdapterInitializer initializer) {
+  adapter_factory.Get().adapter_initializer_ = initializer;

[keybuk, 2014/03/20 01:21:56]

This doesn't run the initializer if the adapter is already initialized by
another part of the code

[rpaquay, 2014/03/20 18:21:11]

The issue is that the "device" layer needs initialization from an upper layer
("extensions::BluetoothAPI"). This is currently specific to Windows only, where
the upper layer needs to pass the FILE thread and net::log instances to the
Windows Adapater implementation.

Other than requiring the upper layer to do guarantee setting the initializer
before the adapter is used, I don't know of any other option.

I am not a fan of this approach, but couldn't think of a better way. Suggestions
are welcome on how to better implement this pattern.

[keybuk, 2014/03/20 18:38:40]

Sure, but the extensions::BluetoothAPI may not be the first component of Chrome
to be initialized... in the case where using the Aura shell, wouldn't be the
Aura UI be initialized first?

The Aura UI holds a reference to the BluetoothAdapter

So when the BluetoothAPI class goes to get it, the existing adapter will just be
returned, and the initializer function won't be called.

[rpaquay, 2014/03/25 20:06:10]

These are all good points. After thinking about this a little bit more, I
decided that it would be best to avoid any additional platform specific global
initialization. To enable that, I had to rethink the threading model a little
bit more, and I think I came up with a simplified model for Windows, very
similar to the way ChromeOS currently works: Consumers always talks to the API
via the UI thread and the platform specific implementation use a dedicated
thread for socket IO. This makes the latest patchset quite big, but I think it
is for the best.

+}
+
+// static
 bool BluetoothAdapterFactory::IsBluetoothAdapterAvailable() {
 #if defined(OS_CHROMEOS)
   return true;
 #elif defined(OS_WIN)
   return true;
 #elif defined(OS_MACOSX)
   return base::mac::IsOSLionOrLater();
+#else
+  return false;
 #endif
-  return false;
 }
 
 // static
 void BluetoothAdapterFactory::GetAdapter(const AdapterCallback& callback) {
   if (!default_adapter.Get().get()) {
 #if defined(OS_CHROMEOS)
     chromeos::BluetoothAdapterChromeOS* new_adapter =
         new chromeos::BluetoothAdapterChromeOS();
+    adapter_factory.Get().adapter_initializer_.Run(new_adapter);
     default_adapter.Get() = new_adapter->weak_ptr_factory_.GetWeakPtr();
 #elif defined(OS_WIN)
     BluetoothAdapterWin* new_adapter = new BluetoothAdapterWin(
         base::Bind(&RunAdapterCallbacks));
     new_adapter->Init();
+    adapter_factory.Get().adapter_initializer_.Run(new_adapter);

[keybuk, 2014/03/20 01:21:56]

the adapter might not be initialized yet?

[rpaquay, 2014/03/20 18:21:11]

The initialization callback is intended to be part of the Adapter instance class
initialization, not part of the "the physical Bluetooth Adapter" is ready.

[keybuk, 2014/03/20 18:38:40]

Ack

     default_adapter.Get() = new_adapter->weak_ptr_factory_.GetWeakPtr();
 #elif defined(OS_MACOSX)
     BluetoothAdapterMac* new_adapter = new BluetoothAdapterMac();
     new_adapter->Init();
+    adapter_factory.Get().adapter_initializer_.Run(new_adapter);

[keybuk, 2014/03/20 01:21:56]

adapter might not be initialized yet

[rpaquay, 2014/03/20 18:21:11]

See Above.

     default_adapter.Get() = new_adapter->weak_ptr_factory_.GetWeakPtr();
 #endif
   }
 
   if (default_adapter.Get()->IsInitialized()) {
     callback.Run(scoped_refptr<BluetoothAdapter>(default_adapter.Get().get()));
   } else {
     adapter_callbacks.Get().push_back(callback);
   }
 }
 
 // static
 scoped_refptr<BluetoothAdapter> BluetoothAdapterFactory::MaybeGetAdapter() {
   return scoped_refptr<BluetoothAdapter>(default_adapter.Get().get());
 }
 
 }  // namespace device