ffmpeg chromium glue

media/filters/ffmpeg_glue_unittest.cc

 // Copyright (c) 2011 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.
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_filters.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
@@ skipping 132 matching lines @@
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol(
       new StrictMock<Destroyable<MockProtocol> >());
   EXPECT_CALL(*protocol, IsStreaming()).WillOnce(Return(true));
   std::string key = glue->AddProtocol(protocol.get());
 
   // Prepare FFmpeg URLContext structure.
   URLContext context;
   memset(&context, 0, sizeof(context));
 
   // Test opening a URLContext with a protocol that doesn't exist.
-  EXPECT_EQ(AVERROR_IO, protocol_->url_open(&context, "foobar", 0));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_open(&context, "foobar", 0));
 
   // Test opening a URLContext with our protocol.
   EXPECT_EQ(0, protocol_->url_open(&context, key.c_str(), 0));
   EXPECT_EQ(URL_RDONLY, context.flags);
   EXPECT_EQ(protocol.get(), context.priv_data);
   EXPECT_TRUE(context.is_streamed);
 
   // We're going to remove references one by one until the last reference is
   // held by FFmpeg.  Once we close the URLContext, the protocol should be
   // destroyed.
@@ skipping 19 matching lines @@
 TEST_F(FFmpegGlueTest, Write) {
   scoped_ptr<StrictMock<MockProtocol> > protocol(
       new StrictMock<MockProtocol>());
   URLContext context;
   OpenContext(protocol.get(), &context);
 
   const int kBufferSize = 16;
   uint8 buffer[kBufferSize];
 
   // Writing should always fail and never call the protocol.
-  EXPECT_EQ(AVERROR_IO, protocol_->url_write(&context, NULL, 0));
-  EXPECT_EQ(AVERROR_IO, protocol_->url_write(&context, buffer, 0));
-  EXPECT_EQ(AVERROR_IO, protocol_->url_write(&context, buffer, kBufferSize));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_write(&context, NULL, 0));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_write(&context, buffer, 0));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_write(&context, buffer, kBufferSize));
 
   // Destroy the protocol.
   protocol_->url_close(&context);
 }
 
 TEST_F(FFmpegGlueTest, Read) {
   scoped_ptr<StrictMock<MockProtocol> > protocol(
       new StrictMock<MockProtocol>());
   URLContext context;
   OpenContext(protocol.get(), &context);
 
   const int kBufferSize = 16;
   uint8 buffer[kBufferSize];
 
   // Reads are for the most part straight-through calls to Read().
   InSequence s;
   EXPECT_CALL(*protocol, Read(0, buffer))
       .WillOnce(Return(0));
   EXPECT_CALL(*protocol, Read(kBufferSize, buffer))
       .WillOnce(Return(kBufferSize));
   EXPECT_CALL(*protocol, Read(kBufferSize, buffer))
       .WillOnce(Return(DataSource::kReadError));
 
   EXPECT_EQ(0, protocol_->url_read(&context, buffer, 0));
   EXPECT_EQ(kBufferSize, protocol_->url_read(&context, buffer, kBufferSize));
-  EXPECT_EQ(AVERROR_IO, protocol_->url_read(&context, buffer, kBufferSize));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_read(&context, buffer, kBufferSize));
 
   // Destroy the protocol.
   protocol_->url_close(&context);
 }
 
 TEST_F(FFmpegGlueTest, Seek) {
   scoped_ptr<StrictMock<MockProtocol> > protocol(
       new StrictMock<MockProtocol>());
   URLContext context;
   OpenContext(protocol.get(), &context);
 
   // SEEK_SET should be a straight-through call to SetPosition(), which when
   // successful will return the result from GetPosition().
   InSequence s;
   EXPECT_CALL(*protocol, SetPosition(-16))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, SetPosition(16))
       .WillOnce(Return(true));
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(8), Return(true)));
 
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, -16, SEEK_SET));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, -16, SEEK_SET));
   EXPECT_EQ(8, protocol_->url_seek(&context, 16, SEEK_SET));
 
   // SEEK_CUR should call GetPosition() first, and if it succeeds add the offset
   // to the result then call SetPosition()+GetPosition().
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(8), Return(true)));
   EXPECT_CALL(*protocol, SetPosition(16))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(8), Return(true)));
   EXPECT_CALL(*protocol, SetPosition(16))
       .WillOnce(Return(true));
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(16), Return(true)));
 
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, 8, SEEK_CUR));
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, 8, SEEK_CUR));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, 8, SEEK_CUR));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, 8, SEEK_CUR));
   EXPECT_EQ(16, protocol_->url_seek(&context, 8, SEEK_CUR));
 
   // SEEK_END should call GetSize() first, and if it succeeds add the offset
   // to the result then call SetPosition()+GetPosition().
   EXPECT_CALL(*protocol, GetSize(_))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, GetSize(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(16), Return(true)));
   EXPECT_CALL(*protocol, SetPosition(8))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, GetSize(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(16), Return(true)));
   EXPECT_CALL(*protocol, SetPosition(8))
       .WillOnce(Return(true));
   EXPECT_CALL(*protocol, GetPosition(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(8), Return(true)));
 
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, -8, SEEK_END));
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, -8, SEEK_END));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, -8, SEEK_END));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, -8, SEEK_END));
   EXPECT_EQ(8, protocol_->url_seek(&context, -8, SEEK_END));
 
   // AVSEEK_SIZE should be a straight-through call to GetSize().
   EXPECT_CALL(*protocol, GetSize(_))
       .WillOnce(Return(false));
 
   EXPECT_CALL(*protocol, GetSize(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(16), Return(true)));
 
-  EXPECT_EQ(AVERROR_IO, protocol_->url_seek(&context, 0, AVSEEK_SIZE));
+  EXPECT_EQ(AVERROR(EIO), protocol_->url_seek(&context, 0, AVSEEK_SIZE));
   EXPECT_EQ(16, protocol_->url_seek(&context, 0, AVSEEK_SIZE));
 
   // Destroy the protocol.
   protocol_->url_close(&context);
 }
 
 TEST_F(FFmpegGlueTest, Destroy) {
   // Create our protocol and add them to the glue layer.
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol(
       new StrictMock<Destroyable<MockProtocol> >());
   std::string key = FFmpegGlue::GetInstance()->AddProtocol(protocol.get());
 
   // We should expect the protocol to get destroyed when the unit test
   // exits.
   InSequence s;
   EXPECT_CALL(mock_ffmpeg_, CheckPoint(0));
   EXPECT_CALL(*protocol, OnDestroy());
 
   // Remove our own reference, we shouldn't be destroyed yet.
   mock_ffmpeg_.CheckPoint(0);
   protocol.reset();
 
   // ~FFmpegGlue() will be called when this unit test finishes execution.  By
   // leaving something inside FFmpegGlue's map we get to test our cleanup code.
 }
 
 }  // namespace media