[Easy Unlock] Port the BluetoothConnectionFinder class to native code.

components/proximity_auth/bluetooth_connection_finder.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 "components/proximity_auth/bluetooth_connection_finder.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "components/proximity_auth/bluetooth_connection.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+
+using device::BluetoothAdapter;
+
+namespace proximity_auth {
+
+BluetoothConnectionFinder::BluetoothConnectionFinder(
+    const RemoteDevice& remote_device,
+    const device::BluetoothUUID& uuid,
+    const base::TimeDelta& polling_interval)
+    : remote_device_(remote_device),
+      uuid_(uuid),
+      polling_interval_(polling_interval),
+      has_delayed_poll_scheduled_(false),
+      weak_ptr_factory_(this) {
+}
+
+BluetoothConnectionFinder::~BluetoothConnectionFinder() {
+  UnregisterAsObserver();
+}
+
+void BluetoothConnectionFinder::Find(
+    const ConnectionCallback& connection_callback) {
+  if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
+    VLOG(1) << "[BCF] Bluetooth is unsupported on this platform. Aborting.";
+    return;
+  }
+
+  DCHECK(start_time_.is_null());
+  VLOG(1) << "[BCF] Finding Bluetooth connection...";
+
+  start_time_ = base::TimeTicks::Now();
+  connection_callback_ = connection_callback;
+
+  device::BluetoothAdapterFactory::GetAdapter(
+      base::Bind(&BluetoothConnectionFinder::OnAdapterInitialized,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+scoped_ptr<Connection> BluetoothConnectionFinder::CreateConnection() {
+  return scoped_ptr<Connection>(new BluetoothConnection(remote_device_, uuid_));
+}
+
+bool BluetoothConnectionFinder::IsReadyToPoll() {
+  bool is_adapter_available =
+      adapter_.get() && adapter_->IsPresent() && adapter_->IsPowered();
+  VLOG(1) << "[BCF] Readiness: adapter="
+          << (is_adapter_available ? "available" : "unavailable");
+  return is_adapter_available;
+}
+
+void BluetoothConnectionFinder::PollIfReady() {
+  if (!IsReadyToPoll())
+    return;
+
+  // If there is a pending task to poll at a later time, the time requisite
+  // timeout has not yet elapsed since the previous polling attempt. In that
+  // case, keep waiting until the delayed task comes in.
+  if (has_delayed_poll_scheduled_)
+    return;
+
+  // If the |connection_| exists, wait for it to connect or fail prior to
+  // polling again.
+  if (connection_)
+    return;
+
+  VLOG(1) << "[BCF] Polling for connection...";
+  connection_ = CreateConnection();
+  connection_->AddObserver(this);
+  connection_->Connect();
+}
+
+void BluetoothConnectionFinder::DelayedPollIfReady() {
+  // Note that there is no longer a pending task, and therefore polling is
+  // permitted.
+  has_delayed_poll_scheduled_ = false;
+  PollIfReady();
+}
+
+void BluetoothConnectionFinder::UnregisterAsObserver() {
+  if (connection_) {
+    connection_->RemoveObserver(this);
+    // The connection is about to be released or destroyed, so no need to clear
+    // it explicitly here.
+  }
+
+  if (adapter_.get()) {
+    adapter_->RemoveObserver(this);
+    adapter_ = NULL;
+  }
+}
+
+void BluetoothConnectionFinder::OnAdapterInitialized(
+    scoped_refptr<BluetoothAdapter> adapter) {
+  adapter_ = adapter;
+  adapter_->AddObserver(this);
+  PollIfReady();
+}
+
+void BluetoothConnectionFinder::AdapterPresentChanged(BluetoothAdapter* adapter,
+                                                      bool present) {
+  PollIfReady();
+}
+
+void BluetoothConnectionFinder::AdapterPoweredChanged(BluetoothAdapter* adapter,
+                                                      bool powered) {
+  PollIfReady();
+}
+
+void BluetoothConnectionFinder::OnConnectionStatusChanged(
+    const Connection& connection,
+    Connection::Status old_status,
+    Connection::Status new_status) {
+  DCHECK_EQ(&connection, connection_.get());
+
+  if (connection_->IsConnected()) {
+    base::TimeDelta elapsed = base::TimeTicks::Now() - start_time_;
+    VLOG(1) << "[BCF] Connection found! Elapsed Time: "
+            << elapsed.InMilliseconds() << "ms.";
+    UnregisterAsObserver();
+    connection_callback_.Run(connection_.Pass());
+  } else if (old_status == Connection::IN_PROGRESS) {
+    VLOG(1) << "[BCF] Connection failed! Scheduling another polling iteration.";
+    connection_.reset();
+    has_delayed_poll_scheduled_ = true;
+    base::MessageLoopProxy::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&BluetoothConnectionFinder::DelayedPollIfReady,
+                   weak_ptr_factory_.GetWeakPtr()),
+        polling_interval_);
+  }
+}
+
+}  // namespace proximity_auth