Using WireMessage instead of FakeWireMessage.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.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/bluetooth_low_energy_device_whitelist.h"
 #include "components/proximity_auth/ble/fake_wire_message.h"
 #include "components/proximity_auth/bluetooth_throttler_impl.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/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/proximity_auth_client.h"
 #include "components/proximity_auth/remote_device.h"
+#include "components/proximity_auth/wire_message.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 198 matching lines @@
   connection_.reset();
   connection_finder_.reset();
 }
 
 void ProximityAuthBleSystem::OnFocusedUserChanged(const std::string& user_id) {
   PA_LOG(INFO) << "OnFocusedUserChanged: " << user_id;
 }
 
 void ProximityAuthBleSystem::OnMessageReceived(const Connection& connection,
                                                const WireMessage& message) {
-  // TODO(sacomoto): change this when WireMessage is fully implemented.
-  PA_LOG(INFO) << "Message received: " << message.payload();
+  PA_LOG(INFO) << "Message with " << message.payload().size()
+               << " bytes received.";
 
   // The first message should contain a public key registered in |unlock_keys_|
   // to authenticate the device.
   if (!device_authenticated_) {
     std::string out_public_key;
     if (HasUnlockKey(message.payload(), &out_public_key)) {
       PA_LOG(INFO) << "Device authenticated. Adding "
                    << connection_->remote_device().bluetooth_address << ", "
                    << out_public_key << " to whitelist.";
       device_whitelist_->AddOrUpdateDevice(
@@ skipping 79 matching lines @@
 void ProximityAuthBleSystem::StartPollingScreenState() {
   PA_LOG(INFO) << "Polling screen state.";
   if (is_polling_screen_state_) {
     if (!connection_ || !connection_->IsConnected()) {
       PA_LOG(INFO) << "Polling stopped.";
       is_polling_screen_state_ = false;
       return;
     }
     // Sends message requesting screen state.
     connection_->SendMessage(
-        make_scoped_ptr(new FakeWireMessage(kPollScreenState)));
+        make_scoped_ptr(new WireMessage(kPollScreenState)));
 
     // Schedules the next message in |kPollingIntervalSeconds| s.
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&ProximityAuthBleSystem::StartPollingScreenState,
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kPollingIntervalSeconds));
 
     PA_LOG(INFO) << "Next poll iteration posted.";
   }
 }
 
 void ProximityAuthBleSystem::StopPollingScreenState() {
   is_polling_screen_state_ = false;
 }
 
 bool ProximityAuthBleSystem::HasUnlockKey(const std::string& message,
                                           std::string* out_public_key) {
   std::string message_prefix(kPublicKeyMessagePrefix);
   if (message.substr(0, message_prefix.size()) != message_prefix)
     return false;
   std::string public_key = message.substr(message_prefix.size());
   if (out_public_key)
     (*out_public_key) = public_key;
   return unlock_keys_.find(public_key) != unlock_keys_.end() ||
          device_whitelist_->HasDeviceWithPublicKey(public_key);
 }
 
 }  // namespace proximity_auth