Encrypting messages send/received from BLE devices.

components/proximity_auth/messenger_impl.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/messenger_impl.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 76 matching lines @@
 void MessengerImpl::AddObserver(MessengerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void MessengerImpl::RemoveObserver(MessengerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool MessengerImpl::SupportsSignIn() const {
   return (secure_context_->GetProtocolVersion() ==
-          SecureContext::PROTOCOL_VERSION_THREE_ONE);
+          SecureContext::PROTOCOL_VERSION_THREE_ONE) &&
+         connection_->remote_device().bluetooth_type !=
+             RemoteDevice::BLUETOOTH_LE;
 }
 
 void MessengerImpl::DispatchUnlockEvent() {
   base::DictionaryValue message;
   message.SetString(kTypeKey, kMessageTypeLocalEvent);
   message.SetString(kNameKey, kUnlockEventName);
   queued_messages_.push_back(PendingMessage(message));
   ProcessMessageQueue();
 }
 
@@ skipping 32 matching lines @@
   ProcessMessageQueue();
 }
 
 MessengerImpl::PendingMessage::PendingMessage() {}
 
 MessengerImpl::PendingMessage::PendingMessage(
     const base::DictionaryValue& message)
     : json_message(SerializeValueToJson(message)),
       type(GetMessageType(message)) {}
 
+MessengerImpl::PendingMessage::PendingMessage(const std::string& message)
+    : json_message(message), type("") {}
+
 MessengerImpl::PendingMessage::~PendingMessage() {}
 
 void MessengerImpl::ProcessMessageQueue() {
   if (pending_message_ || queued_messages_.empty() ||
       connection_->is_sending_message())
     return;
 
   pending_message_.reset(new PendingMessage(queued_messages_.front()));
   queued_messages_.pop_front();
 
   secure_context_->Encode(pending_message_->json_message,
                           base::Bind(&MessengerImpl::OnMessageEncoded,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MessengerImpl::OnMessageEncoded(const std::string& encoded_message) {
   connection_->SendMessage(make_scoped_ptr(new WireMessage(encoded_message)));
 }
 
 void MessengerImpl::OnMessageDecoded(const std::string& decoded_message) {
+  // TODO(tengs): Unify the iOS status update protocol with the existing Android
+  // protocol, so we don't have this special case.
+  if (decoded_message == kScreenUnlocked || decoded_message == kScreenLocked) {
+    RemoteStatusUpdate update;
+    update.user_presence =
+        (decoded_message == kScreenUnlocked ? USER_PRESENT : USER_ABSENT);
+    update.secure_screen_lock_state = SECURE_SCREEN_LOCK_ENABLED;
+    update.trust_agent_state = TRUST_AGENT_ENABLED;
+    FOR_EACH_OBSERVER(MessengerObserver, observers_,
+                      OnRemoteStatusUpdate(update));
+    pending_message_.reset();
+    ProcessMessageQueue();
+    return;
+  }
+
   // The decoded message should be a JSON string.
   scoped_ptr<base::Value> message_value =
       base::JSONReader::Read(decoded_message);
   if (!message_value || !message_value->IsType(base::Value::TYPE_DICTIONARY)) {
     PA_LOG(ERROR) << "Unable to parse message as JSON:\n" << decoded_message;
     return;
   }
 
   base::DictionaryValue* message;
   bool success = message_value->GetAsDictionary(&message);
@@ skipping 77 matching lines @@
 void MessengerImpl::HandleUnlockResponseMessage(
     const base::DictionaryValue& message) {
   FOR_EACH_OBSERVER(MessengerObserver, observers_, OnUnlockResponse(true));
 }
 
 void MessengerImpl::PollScreenStateForIOS() {
   if (!connection_->IsConnected())
     return;
 
   // Sends message requesting screen state.
-  connection_->SendMessage(make_scoped_ptr(new WireMessage(kPollScreenState)));
+  queued_messages_.push_back(PendingMessage(std::string(kPollScreenState)));
+  ProcessMessageQueue();
 
   // Schedules the next message in |kPollingIntervalSeconds|.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&MessengerImpl::PollScreenStateForIOS,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kIOSPollingIntervalSeconds));
 }
 
 void MessengerImpl::OnConnectionStatusChanged(Connection* connection,
                                               Connection::Status old_status,
                                               Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
   if (new_status == Connection::DISCONNECTED) {
     PA_LOG(INFO) << "Secure channel disconnected...";
     connection_->RemoveObserver(this);
     FOR_EACH_OBSERVER(MessengerObserver, observers_, OnDisconnected());
     // TODO(isherman): Determine whether it's also necessary/appropriate to fire
     // this notification from the destructor.
   }
 }
 
 void MessengerImpl::OnMessageReceived(const Connection& connection,
                                       const WireMessage& wire_message) {
-  // TODO(tengs): Unify the iOS status update protocol with the existing Android
-  // protocol, so we don't have this special case.
-  std::string payload = wire_message.payload();
-  if (payload == kScreenUnlocked || payload == kScreenLocked) {
-    RemoteStatusUpdate update;
-    update.user_presence =
-        (payload == kScreenUnlocked ? USER_PRESENT : USER_ABSENT);
-    update.secure_screen_lock_state = SECURE_SCREEN_LOCK_ENABLED;
-    update.trust_agent_state = TRUST_AGENT_ENABLED;
-    FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                      OnRemoteStatusUpdate(update));
-    return;
-  }
-
   secure_context_->Decode(wire_message.payload(),
                           base::Bind(&MessengerImpl::OnMessageDecoded,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MessengerImpl::OnSendCompleted(const Connection& connection,
                                     const WireMessage& wire_message,
                                     bool success) {
   if (!pending_message_) {
     PA_LOG(ERROR) << "Unexpected message sent.";
@@ skipping 21 matching lines @@
   } else {
     PA_LOG(ERROR) << "Message of unknown type '" << pending_message_->type
                   << "' sent.";
   }
 
   pending_message_.reset();
   ProcessMessageQueue();
 }
 
 }  // namespace proximity_auth