Implement debugging local unlock keys in chrome://proximity-auth.

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/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/proximity_auth/bluetooth_connection.h"
+#include "components/proximity_auth/logging/logging.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.";
+    PA_LOG(WARNING) << "Bluetooth is unsupported on this platform. Aborting.";
     return;
   }
 
   DCHECK(start_time_.is_null());
-  VLOG(1) << "[BCF] Finding Bluetooth connection...";
+  PA_LOG(WARNING) << "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");
+  PA_LOG(INFO) << "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...";
+  PA_LOG(INFO) << "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();
@@ skipping 30 matching lines @@
 }
 
 void BluetoothConnectionFinder::OnConnectionStatusChanged(
     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.";
+    PA_LOG(WARNING) << "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.";
+    PA_LOG(WARNING)
+        << "Connection failed! Scheduling another polling iteration.";
     connection_.reset();
     has_delayed_poll_scheduled_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&BluetoothConnectionFinder::DelayedPollIfReady,
                               weak_ptr_factory_.GetWeakPtr()),
         polling_interval_);
   }
 }
 
 }  // namespace proximity_auth