1 files changed, 48 insertions, 48 deletions

diff --git a/chromium/media/cast/video_receiver/video_decoder_unittest.cc b/chromium/media/cast/video_receiver/video_decoder_unittest.cc
index 0b95d128b75..6405d1d7bee 100644
--- a/chromium/media/cast/video_receiver/video_decoder_unittest.cc
+++ b/chromium/media/cast/video_receiver/video_decoder_unittest.cc
@@ -3,11 +3,13 @@
 // found in the LICENSE file.
 
 #include "base/bind.h"
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "base/time/tick_clock.h"
+#include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/cast_thread.h"
+#include "media/cast/cast_environment.h"
+#include "media/cast/cast_receiver.h"
 #include "media/cast/test/fake_task_runner.h"
 #include "media/cast/video_receiver/video_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -19,76 +21,74 @@ using testing::_;
 
 // Random frame size for testing.
 const int kFrameSize = 2345;
+static const int64 kStartMillisecond = GG_INT64_C(1245);
 
-static void ReleaseFrame(const EncodedVideoFrame* encoded_frame) {
-  // Empty since we in this test send in the same frame.
-}
-
-class TestVideoDecoderCallback :
-    public base::RefCountedThreadSafe<TestVideoDecoderCallback> {
+namespace {
+class DecodeTestFrameCallback :
+  public base::RefCountedThreadSafe<DecodeTestFrameCallback> {
  public:
-  TestVideoDecoderCallback()
-      : num_called_(0) {}
-  // TODO(mikhal): Set and check expectations.
-  void DecodeComplete(scoped_ptr<I420VideoFrame> frame,
-      const base::TimeTicks render_time) {
-    num_called_++;
-  }
+  DecodeTestFrameCallback() {}
 
-  int number_times_called() {return num_called_;}
+  void DecodeComplete(const scoped_refptr<media::VideoFrame>& decoded_frame,
+                      const base::TimeTicks& render_time) {}
+ protected:
+  virtual ~DecodeTestFrameCallback() {}
  private:
-  int num_called_;
+  friend class base::RefCountedThreadSafe<DecodeTestFrameCallback>;
 };
+}  // namespace
 
 class VideoDecoderTest : public ::testing::Test {
  protected:
-  VideoDecoderTest() {
+  VideoDecoderTest()
+    : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
+      cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
+          task_runner_, task_runner_, task_runner_, task_runner_,
+          GetDefaultCastLoggingConfig())),
+      test_callback_(new DecodeTestFrameCallback()) {
     // Configure to vp8.
     config_.codec = kVp8;
     config_.use_external_decoder = false;
-    video_decoder_callback_ = new TestVideoDecoderCallback();
+    decoder_.reset(new VideoDecoder(config_, cast_environment_));
+    testing_clock_.Advance(
+        base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
-  ~VideoDecoderTest() {}
-  virtual void SetUp() {
-    task_runner_ = new test::FakeTaskRunner(&testing_clock_);
-    cast_thread_ = new CastThread(task_runner_, task_runner_, task_runner_,
-                                  task_runner_, task_runner_);
-    decoder_ = new VideoDecoder(cast_thread_, config_);
-  }
+  virtual ~VideoDecoderTest() {}
 
-  scoped_refptr<VideoDecoder> decoder_;
+  scoped_ptr<VideoDecoder> decoder_;
   VideoReceiverConfig config_;
-  EncodedVideoFrame encoded_frame_;
   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<test::FakeTaskRunner> task_runner_;
-  scoped_refptr<CastThread> cast_thread_;
-  scoped_refptr<TestVideoDecoderCallback> video_decoder_callback_;
+  scoped_refptr<CastEnvironment> cast_environment_;
+  scoped_refptr<DecodeTestFrameCallback> test_callback_;
 };
 
-// TODO(pwestin): Test decoding a real frame.
-TEST_F(VideoDecoderTest, SizeZero) {
-  encoded_frame_.codec = kVp8;
+// TODO(pwestin): EXPECT_DEATH tests can not pass valgrind.
+TEST_F(VideoDecoderTest, DISABLED_SizeZero) {
+  EncodedVideoFrame encoded_frame;
   base::TimeTicks render_time;
-  VideoFrameDecodedCallback frame_decoded_callback =
-      base::Bind(&TestVideoDecoderCallback::DecodeComplete,
-                 video_decoder_callback_.get());
-  decoder_->DecodeVideoFrame(&encoded_frame_, render_time,
-      frame_decoded_callback, base::Bind(ReleaseFrame, &encoded_frame_));
-  EXPECT_EQ(0, video_decoder_callback_->number_times_called());
+  encoded_frame.codec = kVp8;
+  EXPECT_DEATH(
+      decoder_->DecodeVideoFrame(
+          &encoded_frame, render_time,
+          base::Bind(&DecodeTestFrameCallback::DecodeComplete, test_callback_)),
+      "Empty frame");
 }
 
-TEST_F(VideoDecoderTest, InvalidCodec) {
+// TODO(pwestin): EXPECT_DEATH tests can not pass valgrind.
+TEST_F(VideoDecoderTest, DISABLED_InvalidCodec) {
+  EncodedVideoFrame encoded_frame;
   base::TimeTicks render_time;
-  VideoFrameDecodedCallback frame_decoded_callback =
-      base::Bind(&TestVideoDecoderCallback::DecodeComplete,
-                 video_decoder_callback_.get());
-  encoded_frame_.data.assign(kFrameSize, 0);
-  encoded_frame_.codec = kExternalVideo;
-  EXPECT_DEATH(decoder_->DecodeVideoFrame(&encoded_frame_, render_time,
-      frame_decoded_callback, base::Bind(ReleaseFrame, &encoded_frame_)),
-          "Invalid codec");
+  encoded_frame.data.assign(kFrameSize, 0);
+  encoded_frame.codec = kExternalVideo;
+  EXPECT_DEATH(
+      decoder_->DecodeVideoFrame(&encoded_frame, render_time, base::Bind(
+          &DecodeTestFrameCallback::DecodeComplete, test_callback_)),
+      "Invalid codec");
 }
 
+// TODO(pwestin): Test decoding a real frame.
+
 }  // namespace cast
 }  // namespace media