[Proximity Auth] Create one ProximityAuthClient per profile, rather than one global one.

components/proximity_auth/ble/proximity_auth_ble_system.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/ble/proximity_auth_ble_system.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/ble/fake_wire_message.h"
 #include "components/proximity_auth/connection.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
 #include "components/proximity_auth/cryptauth/cryptauth_client.h"
+#include "components/proximity_auth/proximity_auth_client.h"
 #include "components/proximity_auth/remote_device.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 
 namespace proximity_auth {
 
 namespace {
 
 // The UUID of the Bluetooth Low Energy service.
 const char kSmartLockServiceUUID[] = "b3b7e28e-a000-3e17-bd86-6e97b9e28c11";
@@ skipping 34 matching lines @@
     ScreenlockBridge::Observer* observer) {
   screenlock_bridge_->AddObserver(observer);
 }
 
 void ProximityAuthBleSystem::ScreenlockBridgeAdapter::RemoveObserver(
     ScreenlockBridge::Observer* observer) {
   screenlock_bridge_->RemoveObserver(observer);
 }
 
 void ProximityAuthBleSystem::ScreenlockBridgeAdapter::Unlock(
-    content::BrowserContext* browser_context) {
-  screenlock_bridge_->Unlock(browser_context);
+    ProximityAuthClient* client) {
+  screenlock_bridge_->Unlock(client->GetAuthenticatedUsername());
 }
 
 ProximityAuthBleSystem::ProximityAuthBleSystem(
     ScreenlockBridge* screenlock_bridge,
-    content::BrowserContext* browser_context,
+    ProximityAuthClient* proximity_auth_client,
     scoped_ptr<CryptAuthClientFactory> cryptauth_client_factory)
     : screenlock_bridge_(new ProximityAuthBleSystem::ScreenlockBridgeAdapter(
           screenlock_bridge)),
-      browser_context_(browser_context),
+      proximity_auth_client_(proximity_auth_client),
       cryptauth_client_factory_(cryptauth_client_factory.Pass()),
       is_polling_screen_state_(false),
       weak_ptr_factory_(this) {
   VLOG(1) << "Starting Proximity Auth over Bluetooth Low Energy.";
   screenlock_bridge_->AddObserver(this);
 }
 
 ProximityAuthBleSystem::ProximityAuthBleSystem(
-    ScreenlockBridgeAdapter* screenlock_bridge,
-    content::BrowserContext* browser_context)
-    : screenlock_bridge_(screenlock_bridge),
-      browser_context_(browser_context),
+    scoped_ptr<ScreenlockBridgeAdapter> screenlock_bridge,
+    ProximityAuthClient* proximity_auth_client)
+    : screenlock_bridge_(screenlock_bridge.Pass()),
+      proximity_auth_client_(proximity_auth_client),
       is_polling_screen_state_(false),
       weak_ptr_factory_(this) {
   VLOG(1) << "Starting Proximity Auth over Bluetooth Low Energy.";
   screenlock_bridge_->AddObserver(this);
 }
 
 ProximityAuthBleSystem::~ProximityAuthBleSystem() {
   VLOG(1) << "Stopping Proximity over Bluetooth Low Energy.";
   screenlock_bridge_->RemoveObserver(this);
   if (connection_)
@@ skipping 95 matching lines @@
                                                const WireMessage& message) {
   VLOG(1) << "Message received: " << message.payload();
 
   // Unlock the screen when the remote device sends an unlock signal.
   //
   // Note that this magically unlocks Chrome (no user interaction is needed).
   // This user experience for this operation will be greately improved once
   // the Proximity Auth Unlock Manager migration to C++ is done.
   if (message.payload() == kScreenUnlocked) {
     VLOG(1) << "Device unlocked. Unlock.";
-    screenlock_bridge_->Unlock(browser_context_);
+    screenlock_bridge_->Unlock(proximity_auth_client_);
   }
 }
 
 void ProximityAuthBleSystem::OnConnectionFound(
     scoped_ptr<Connection> connection) {
   VLOG(1) << "Connection found.";
 
   connection_ = connection.Pass();
   if (connection_) {
     connection_->AddObserver(this);
@@ skipping 41 matching lines @@
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kPollingIntervalSeconds));
   }
 }
 
 void ProximityAuthBleSystem::StopPollingScreenState() {
   is_polling_screen_state_ = false;
 }
 
 }  // namespace proximity_auth