Blimp: define HeliumTransport/HeliumStream interfaces.

blimp/net/helium/helium_transport.h

Index: blimp/net/helium/helium_transport.h
diff --git a/blimp/net/helium/helium_transport.h b/blimp/net/helium/helium_transport.h
new file mode 100644
index 0000000000000000000000000000000000000000..42d9029dc6fe11614a75f0166200e9b46e8cdabc
--- /dev/null
+++ b/blimp/net/helium/helium_transport.h
@@ -0,0 +1,33 @@
+// Copyright 2016 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 BLIMP_NET_HELIUM_HELIUM_TRANSPORT_H_
+#define BLIMP_NET_HELIUM_HELIUM_TRANSPORT_H_
+
+#include <memory>
+
+#include "base/callback.h"
+
+namespace blimp {
+
+// Abstract interface for a HeliumStream factory. Subclasses can use this
+// interface to encapsulate transport-specific connection semantics.
+class HeliumTransport {

[Garrett Casto, 2016/09/30 16:58:42]

Add OnStreamAccepted()?

[Kevin M, 2016/09/30 22:20:56]

I was thinking that |connect_cb| would suffice for that?

[Garrett Casto, 2016/10/03 22:06:00]

There should be a distinction between "I want to create a new HeliumStream", and
you get a Stream which you can send data on, and "The peer has created a stream
that you should get". You want to be able to distinguish between these two cases
so you know if you should be sending first or reading first.

Also, I think that the receiving a stream should probably be a delegate/observer
since I don't think there is ever a time when we don't want to be notified that
a new stream is here. 

[Kevin M, 2016/10/04 01:33:08]

Agreed that we'll want a delegate because new incoming streams can be connected
without the reciepient having called Connect. I'm not sure if it matters whether
or not the stream was initiated by the local side or by the peer, though, since
we are allowing a designated part of the sync manager (Engine?) to migrate
objects across streams and handle the subsequent message reordering. 

+ public:
+  // The HeliumStream is assumed to be authenticated and ready to use.
+  // |stream| is nullptr if the connection attempt failed.
+  using ConnectCallback =
+      base::Callback<void(std::unique_ptr<HeliumStream> stream)>;
+
+  // Asynchronously attempts to connect a new HeliumStream.
+  virtual void Connect(const ConnectCallback& connect_cb) = 0;
+
+  // Returns true if the underlying transport has the necessary resources (e.g.
+  // network connectivity) to Connect() new streams.
+  virtual bool IsAvailable() = 0;
+};
+
+}  // namespace blimp
+
+#endif  // BLIMP_NET_HELIUM_HELIUM_TRANSPORT_H_