Hook up ProximityAuthSystem in EasyUnlockService.

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"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/proximity_auth/connection.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger_observer.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/wire_message.h"
 
 namespace proximity_auth {
 namespace {
 
 // The key names of JSON fields for messages sent between the devices.
 const char kTypeKey[] = "type";
 const char kNameKey[] = "name";
 const char kDataKey[] = "data";
 const char kEncryptedDataKey[] = "encrypted_data";
 
 // The types of messages that can be sent and received.
 const char kMessageTypeLocalEvent[] = "event";
 const char kMessageTypeRemoteStatusUpdate[] = "status_update";
 const char kMessageTypeDecryptRequest[] = "decrypt_request";
 const char kMessageTypeDecryptResponse[] = "decrypt_response";
 const char kMessageTypeUnlockRequest[] = "unlock_request";
 const char kMessageTypeUnlockResponse[] = "unlock_response";
 
 // The name for an unlock event originating from the local device.
 const char kUnlockEventName[] = "easy_unlock";
 
+// Messages sent and received from the iOS app when polling for it's lock screen
+// status.
+// TODO(tengs): Unify the iOS status update protocol with the existing Android
+// protocol, so we don't have this special case.
+const char kPollScreenState[] = "PollScreenState";
+const char kScreenUnlocked[] = "Screen Unlocked";
+const char kScreenLocked[] = "Screen Locked";
+const int kIOSPollingIntervalSeconds = 5;
+
 // Serializes the |value| to a JSON string and returns the result.
 std::string SerializeValueToJson(const base::Value& value) {
   std::string json;
   base::JSONWriter::Write(value, &json);
   return json;
 }
 
 // Returns the message type represented by the |message|. This is a convenience
 // wrapper that should only be called when the |message| is known to specify its
 // message type, i.e. this should not be called for untrusted input.
 std::string GetMessageType(const base::DictionaryValue& message) {
   std::string type;
   message.GetString(kTypeKey, &type);
   return type;
 }
 
 }  // namespace
 
 MessengerImpl::MessengerImpl(scoped_ptr<Connection> connection,
                              scoped_ptr<SecureContext> secure_context)
     : connection_(connection.Pass()),
       secure_context_(secure_context.Pass()),
       weak_ptr_factory_(this) {
   DCHECK(connection_->IsConnected());
   connection_->AddObserver(this);
+
+  // TODO(tengs): We need CryptAuth to report if the phone runs iOS or Android,
+  // rather than relying on this heuristic.
+  if (connection_->remote_device().bluetooth_type == RemoteDevice::BLUETOOTH_LE)
+    PollScreenStateForIOS();
 }
 
 MessengerImpl::~MessengerImpl() {
   if (connection_)
     connection_->RemoveObserver(this);
 }
 
 void MessengerImpl::AddObserver(MessengerObserver* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 162 matching lines @@
   }
   FOR_EACH_OBSERVER(MessengerObserver, observers_,
                     OnDecryptResponse(response.Pass()));
 }
 
 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)));

[sacomoto, 2015/10/01 16:09:08]

We should encrypt the messages to iOS too.

+
+  // 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);
-    connection_.reset();
     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();

[sacomoto, 2015/10/01 16:09:08]

This message should be encrypted too.

+  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