Cast Streaming API end-to-end browser_test.

media/cast/test/utility/in_process_receiver.h

Index: media/cast/test/utility/in_process_receiver.h
diff --git a/media/cast/test/utility/in_process_receiver.h b/media/cast/test/utility/in_process_receiver.h
new file mode 100644
index 0000000000000000000000000000000000000000..795e7e0855cc9d30d2d7c6c9a95875af7470dac7
--- /dev/null
+++ b/media/cast/test/utility/in_process_receiver.h
@@ -0,0 +1,108 @@
+// 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 MEDIA_CAST_TEST_IN_PROCESS_RECEIVER_H_
+#define MEDIA_CAST_TEST_IN_PROCESS_RECEIVER_H_
+
+#include "base/memory/ref_counted.h"
+#include "media/cast/cast_config.h"
+#include "media/cast/transport/cast_transport_config.h"
+
+namespace base {
+class TimeTicks;
+}  // namespace base
+
+namespace net {
+class IPEndPoint;
+}  // namespace net
+
+namespace media {
+
+class VideoFrame;
+
+namespace cast {
+
+class CastEnvironment;
+class CastReceiver;
+
+namespace transport {
+class UdpTransport;
+}  // namespace transport
+
+// Common base functionality for an in-process Cast receiver.  This is meant to
+// be subclassed with the OnAudioFrame() and OnVideoFrame() methods implemented,
+// so that the implementor can focus on what is to be done with the frames,
+// rather than on the boilerplate "glue" code.
+class InProcessReceiver : public base::RefCountedThreadSafe<InProcessReceiver> {
+ public:
+  // Construct a receiver with the given configuration.  |remote_end_point| can
+  // be left empty, if the transport should automatically mate with the first
+  // remote sender it encounters.
+  InProcessReceiver(const scoped_refptr<CastEnvironment>& cast_environment,
+                    const net::IPEndPoint& local_end_point,
+                    const net::IPEndPoint& remote_end_point,
+                    const AudioReceiverConfig& audio_config,
+                    const VideoReceiverConfig& video_config);
+
+  // Convenience accessor to CastEnvironment.
+  scoped_refptr<CastEnvironment> cast_env() const { return cast_environment_; }
+
+  // Begin delivering any received audio/video frames to the OnXXXFrame()
+  // methods.
+  virtual void Start();
+
+  // Initiate shutdown, non-blocking.  Frames may be delivered after this, but
+  // with the guarantee that the system will eventually shut down.

[hubbe, 2014/03/06 19:54:43]

This raises some questions about when it is safe to destroy this class.
Seems like we either need some way to wait until everything is stopped, or we
need to guarantee that destroying this class is *always* safe.

If the cast receiver works anything like the cast sender, then it should always
be safe to destroy the class.

[miu, 2014/03/07 22:40:29]

Re-worked this as discussed.  InProcessReceiver is no longer ref-counted, and
runs entirely on the Cast MAIN thread once Start() is invoked.

+  virtual void StopSoon();
+
+ protected:
+  virtual ~InProcessReceiver();
+
+  // To be implemented by subclasses.  These are called on the Cast MAIN thread
+  // as each frame is received.
+  virtual void OnAudioFrame(scoped_ptr<PcmAudioFrame> audio_frame,
+                            const base::TimeTicks& playout_time) = 0;
+  virtual void OnVideoFrame(const scoped_refptr<VideoFrame>& video_frame,
+                            const base::TimeTicks& render_time) = 0;
+
+  // Callback for the transport to notify of status changes.  A default
+  // implementation is provided here that simply logs socket errors.
+  virtual void UpdateCastTransportStatus(transport::CastTransportStatus status);
+
+ private:
+  friend class base::RefCountedThreadSafe<InProcessReceiver>;
+
+  // Helper method that creates |transport_| and |cast_receiver_|, starts
+  // |transport_| receiving, and requests the first audio/video frame.
+  void StartOnMainThread();
+
+  // Destroys |transport_| and |cast_receiver_|.  No further frames will be
+  // requested after this method returns, although there may be requests still
+  // in-flight in the task runner queues.
+  void StopOnMainThread();
+
+  // CastReceiver callbacks that receive a frame and then request another.
+  void GotAudioFrame(scoped_ptr<PcmAudioFrame> audio_frame,
+                     const base::TimeTicks& playout_time);
+  void GotVideoFrame(const scoped_refptr<VideoFrame>& video_frame,
+                     const base::TimeTicks& render_time);
+  void PullNextAudioFrame();
+  void PullNextVideoFrame();
+
+  const scoped_refptr<CastEnvironment> cast_environment_;
+  const net::IPEndPoint local_end_point_;
+  const net::IPEndPoint remote_end_point_;
+  const AudioReceiverConfig audio_config_;
+  const VideoReceiverConfig video_config_;
+
+  scoped_ptr<transport::UdpTransport> transport_;
+  scoped_ptr<CastReceiver> cast_receiver_;
+
+  DISALLOW_COPY_AND_ASSIGN(InProcessReceiver);
+};
+
+}  // namespace cast
+}  // namespace media
+
+#endif  // MEDIA_CAST_TEST_IN_PROCESS_RECEIVER_H_