Blimp: define HeliumTransport/HeliumStream interfaces.

blimp/net/helium/helium_stream.h

+// 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_STREAM_H_
+#define BLIMP_NET_HELIUM_HELIUM_STREAM_H_
+
+#include <memory>
+
+#include "base/observer_list.h"
+#include "net/base/completion_callback.h"
+
+namespace blimp {
+
+class HeliumMessage;
+
+// Abstract base class for HeliumMessage-oriented transport streams.
+// Details about how the HeliumStream is bound to the network layer are handled
+// by subclasses of HeliumStream.
+class HeliumStream {
+ public:
+  class Observer {
+   public:
+    // Informs observers that the HeliumStream is disconnected.
+    // Any outstanding read or write callbacks will be dropped and never
+    // invoked.
+    //
+    // An observer which owns |this| may delete the HeliumStream in response to
+    // receiving an OnStreamDisconnected() notification. The deletion method
+    // must be asynchronously posted to occur *after* the OnStreamDisconnected()
+    // handler, not during.
+    virtual void OnStreamDisconnected(HeliumStream* stream) = 0;
+  };
+
+  HeliumStream();
+  virtual ~HeliumStream();
+
+  // Sends |helium_message| over the Stream. |callback| is invoked when the
+  // message is sent (or otherwise moved to the low-level write buffers),
+  // which signals the caller that it is clear to send another message.
+  //
+  // The caller is responsible for ensuring that only one outstanding
+  // SendMessage() call is made at a time.
+  virtual void SendMessage(std::unique_ptr<HeliumMessage> helium_message,
+                           const net::CompletionCallback& callback) = 0;

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

Nit: We may want to define our own callback since we aren't going to use the
same error space as //net and I don't think that we care about returning the
size of the data written so we can use an enum directly instead having to cast
from an integer.

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

Done.

+
+  // Asynchronously reads a HeliumMessage from the stream.
+  // The caller is responsible for ensuring that only one outstanding
+  // ReceiveMessage() call is made at a time.
+  // The implementation classes should refrain from preemptively buffering
+  // incoming messages to ensure proper pushback w/transport-level flow control.
+  virtual void ReceiveMessage(
+      base::Callback<void(std::unique_ptr<HeliumMessage>)> on_receive_cb) = 0;

[Garrett Casto, 2016/09/30 17:46:20]

Also, we are eventually going to want to return a status as well as just the
HeliumMessage here.

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

Done.

+
+  // Lets other objects observe the Stream for major state changes (e.g.
+  // connectivity).
+  void AddObserver(Observer* observer);
+
+ protected:
+  // Notifies observers that the underlying transport for this Stream is no
+  // longer connected. Must be called by a subclass before the HeliumStream
+  // can be torn down.
+  void NotifyStreamDisconnected();
+
+ private:
+  base::ObserverList<HeliumStream::Observer> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(HeliumStream);
+};
+
+}  // namespace blimp
+
+#endif  // BLIMP_NET_HELIUM_HELIUM_STREAM_H_