Hook up ProximityAuthSystem in EasyUnlockService.

components/proximity_auth/proximity_monitor_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/proximity_monitor_impl.h"
 
 #include <math.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 14 matching lines @@
 const int kPollingTimeoutMs = 250;
 
 // The RSSI threshold below which we consider the remote device to not be in
 // proximity.
 const int kRssiThreshold = -5;
 
 // The weight of the most recent RSSI sample.
 const double kRssiSampleWeight = 0.3;
 
 ProximityMonitorImpl::ProximityMonitorImpl(const RemoteDevice& remote_device,
-                                           scoped_ptr<base::TickClock> clock,
-                                           ProximityMonitorObserver* observer)
+                                           scoped_ptr<base::TickClock> clock)
     : remote_device_(remote_device),
-      observer_(observer),
       strategy_(Strategy::NONE),
       remote_device_is_in_proximity_(false),
       is_active_(false),
       clock_(clock.Pass()),
       polling_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&ProximityMonitorImpl::OnAdapterInitialized,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 56 matching lines @@
   std::string remote_device_model = metrics::kUnknownDeviceModel;
   if (remote_device_.name != remote_device_.bluetooth_address)
     remote_device_model = remote_device_.name;
 
   metrics::RecordAuthProximityRollingRssi(round(rssi_rolling_average));
   metrics::RecordAuthProximityTransmitPowerDelta(last_transmit_power_delta);
   metrics::RecordAuthProximityTimeSinceLastZeroRssi(time_since_last_zero_rssi);
   metrics::RecordAuthProximityRemoteDeviceModelHash(remote_device_model);
 }
 
+void ProximityMonitorImpl::AddObserver(ProximityMonitorObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ProximityMonitorImpl::RemoveObserver(ProximityMonitorObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void ProximityMonitorImpl::SetStrategy(Strategy strategy) {
   if (strategy_ == strategy)
     return;
   strategy_ = strategy;
   CheckForProximityStateChange();
   UpdatePollingState();
 }
 
 ProximityMonitorImpl::TransmitPowerReading::TransmitPowerReading(
     int transmit_power,
@@ skipping 80 matching lines @@
                     << connection_info.rssi << " "
                     << connection_info.transmit_power << " "
                     << connection_info.max_transmit_power;
     rssi_rolling_average_.reset();
     last_transmit_power_reading_.reset();
     CheckForProximityStateChange();
   }
 }
 
 void ProximityMonitorImpl::ClearProximityState() {
-  if (is_active_ && remote_device_is_in_proximity_)
-    observer_->OnProximityStateChanged();
+  if (is_active_ && remote_device_is_in_proximity_) {
+    FOR_EACH_OBSERVER(ProximityMonitorObserver, observers_,
+                      OnProximityStateChanged());
+  }
 
   remote_device_is_in_proximity_ = false;
   rssi_rolling_average_.reset();
   last_transmit_power_reading_.reset();
   last_zero_rssi_timestamp_.reset();
 }
 
 void ProximityMonitorImpl::AddSample(
     const BluetoothDevice::ConnectionInfo& connection_info) {
   double weight = kRssiSampleWeight;
@@ skipping 29 matching lines @@
     case Strategy::CHECK_TRANSMIT_POWER:
       is_now_in_proximity = (last_transmit_power_reading_ &&
                              last_transmit_power_reading_->IsInProximity());
       break;
   }
 
   if (remote_device_is_in_proximity_ != is_now_in_proximity) {
     PA_LOG(INFO) << "[Proximity] Updated proximity state: "
                  << (is_now_in_proximity ? "proximate" : "distant");
     remote_device_is_in_proximity_ = is_now_in_proximity;
-    observer_->OnProximityStateChanged();
+    FOR_EACH_OBSERVER(ProximityMonitorObserver, observers_,
+                      OnProximityStateChanged());
   }
 }
 
 }  // namespace proximity_auth