[EasyUnlock] Port Connection class to native code.

components/proximity_auth/connection_observer.h

+// 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.
+
+#ifndef COMPONENTS_PROXIMITY_AUTH_CONNECTION_OBSERVER_H
+#define COMPONENTS_PROXIMITY_AUTH_CONNECTION_OBSERVER_H
+
+#include "components/proximity_auth/connection.h"
+
+namespace proximity_auth {
+
+class PermitMessage;
+
+// An interface for observing events that happen on a Connection.
+class ConnectionObserver {
+ public:
+  // Called when the |connection|'s status changes from |old_status| to
+  // |new_status|.
+  virtual void OnConnectionStatusChanged(const Connection& connection,
+                                         Connection::Status old_status,
+                                         Connection::Status new_status) = 0;
+
+  // Called when a |message| is received from a remote device over the
+  // |connection|.
+  virtual void OnMessageReceived(const Connection& connection,
+                                 const PermitMessage& message) = 0;

[Tim Song, 2014/09/05 00:30:34]

Mention that |message| shouldn't be kept around (eg. for binding to a posted
task). 

Do we want to use a scoped_refptr in Connection instead to avoid these potential
problems?

[Ilya Sherman, 2014/09/05 01:02:11]

I'm not sure what the concern is.  It's pretty much never safe to assume that
you can save a local reference to a variable passed in by const-ref.  On the
other hand, if the observer makes a copy of the message, then what's wrong with
keeping it around?

I'm quite opposed to using reference counting unless we have to, as it makes
memory ownership quite hard to keep track of.  Since wire messages should be
fairly cheap to copy, I'd prefer to just copy the data when necessary.

[Tim Song, 2014/09/05 03:10:33]

It's easy to make such a mistake with Bind, since you're not explicitly storing
the reference. The SecureMessage decryption is asynchronous, so we have to be
careful not to bind members of the reference to the WireMessage. I suppose a
comment won't really help you avoid that mistake though.

+
+  // Called after a |message| is sent to the remote device over the
+  // |connection|. |success| is |true| iff the message is sent successfully.
+  virtual void OnSendCompleted(const Connection& connection,
+                               const PermitMessage& message,
+                               bool success) = 0;
+};
+
+}  // namespace proximity_auth
+
+#endif  // COMPONENTS_PROXIMITY_AUTH_CONNECTION_OBSERVER_H