Hook up ProximityAuthSystem in EasyUnlockService.

components/proximity_auth/remote_device_life_cycle_impl.cc

 // Copyright 2015 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/remote_device_life_cycle_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
@@ skipping 25 matching lines @@
 const int kAuthenticationRecoveryTimeSeconds = 10;
 
 }  // namespace
 
 RemoteDeviceLifeCycleImpl::RemoteDeviceLifeCycleImpl(
     const RemoteDevice& remote_device,
     ProximityAuthClient* proximity_auth_client)
     : remote_device_(remote_device),
       proximity_auth_client_(proximity_auth_client),
       state_(RemoteDeviceLifeCycle::State::STOPPED),
+      observers_(base::ObserverList<Observer>::NOTIFY_EXISTING_ONLY),
       bluetooth_throttler_(new BluetoothThrottlerImpl(
           make_scoped_ptr(new base::DefaultTickClock()))),
       weak_ptr_factory_(this) {}
 
 RemoteDeviceLifeCycleImpl::~RemoteDeviceLifeCycleImpl() {}
 
 void RemoteDeviceLifeCycleImpl::Start() {
   PA_LOG(INFO) << "Life cycle started.";
   DCHECK(state_ == RemoteDeviceLifeCycle::State::STOPPED);
   FindConnection();
@@ skipping 10 matching lines @@
 void RemoteDeviceLifeCycleImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void RemoteDeviceLifeCycleImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 scoped_ptr<ConnectionFinder>
 RemoteDeviceLifeCycleImpl::CreateConnectionFinder() {
-  // TODO(tengs): We should not rely on the assumption that an empty Bluetooth
-  // address means that the device is BLE.
-  if (remote_device_.bluetooth_address.empty()) {
+  if (remote_device_.bluetooth_type == RemoteDevice::BLUETOOTH_LE) {
     return make_scoped_ptr(new BluetoothLowEnergyConnectionFinder(
         remote_device_, kBLESmartLockServiceUUID,
         BluetoothLowEnergyConnectionFinder::FinderStrategy::FIND_PAIRED_DEVICE,
         nullptr, bluetooth_throttler_.get(), 3));
   } else {
     return make_scoped_ptr(new BluetoothConnectionFinder(
         remote_device_, device::BluetoothUUID(kClassicBluetoothServiceUUID),
         base::TimeDelta::FromSeconds(3)));
   }
 }
@@ skipping 30 matching lines @@
   authenticator_->Authenticate(
       base::Bind(&RemoteDeviceLifeCycleImpl::OnAuthenticationResult,
                  weak_ptr_factory_.GetWeakPtr()));
   TransitionToState(RemoteDeviceLifeCycle::State::AUTHENTICATING);
 }
 
 void RemoteDeviceLifeCycleImpl::OnAuthenticationResult(
     Authenticator::Result result,
     scoped_ptr<SecureContext> secure_context) {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::AUTHENTICATING);
+  authenticator_.reset();
   if (result != Authenticator::Result::SUCCESS) {
     PA_LOG(WARNING) << "Waiting " << kAuthenticationRecoveryTimeSeconds
                     << " seconds to retry after authentication failure.";
     connection_->Disconnect();
     authentication_recovery_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kAuthenticationRecoveryTimeSeconds), this,
         &RemoteDeviceLifeCycleImpl::FindConnection);
     TransitionToState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
     return;
   }
 
   // Create the MessengerImpl asynchronously. |messenger_| registers itself as
-  // an
-  // observer of |connection_|, so creating it synchronously would
-  // trigger |OnSendComplete()| as an observer call for |messenger_|.
+  // an observer of |connection_|, so creating it synchronously would trigger
+  // |OnSendCompleted()| as an observer call for |messenger_|.
   secure_context_ = secure_context.Pass();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&RemoteDeviceLifeCycleImpl::CreateMessenger,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RemoteDeviceLifeCycleImpl::CreateMessenger() {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::AUTHENTICATING);
   DCHECK(secure_context_);
   messenger_.reset(
       new MessengerImpl(connection_.Pass(), secure_context_.Pass()));
   messenger_->AddObserver(this);
 
   TransitionToState(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
 }
 
 void RemoteDeviceLifeCycleImpl::OnDisconnected() {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  messenger_.reset();
   FindConnection();
 }
 
 }  // namespace proximity_auth