Fix heapchecker failure due to not deleting AVStream*[].

media/filters/chunk_demuxer_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/base_paths.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "media/base/media.h"
 #include "media/base/mock_callback.h"
@@ skipping 39 matching lines @@
     codecs_[VIDEO].width = 320;
     codecs_[VIDEO].height = 240;
 
     codecs_[AUDIO].codec_type = AVMEDIA_TYPE_AUDIO;
     codecs_[AUDIO].codec_id = CODEC_ID_VORBIS;
     codecs_[AUDIO].channels = 2;
     codecs_[AUDIO].sample_rate = 44100;
   }
 
   virtual ~ChunkDemuxerTest() {
-    if (demuxer_.get())
-      demuxer_->Shutdown();
-    if (format_context_.streams) {
-      delete[] format_context_.streams;
-      format_context_.streams = NULL;
-      format_context_.nb_streams = 0;
-    }
+    ShutdownDemuxer();
   }
 
   void ReadFile(const std::string& name, scoped_array<uint8>* buffer,
                 int* size) {
     FilePath file_path;
     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
     file_path = file_path.Append(FILE_PATH_LITERAL("media"))
         .Append(FILE_PATH_LITERAL("test"))
         .Append(FILE_PATH_LITERAL("data"))
         .AppendASCII(name);
@@ skipping 56 matching lines @@
       memcpy(buf, audio_track_entry.get(), audio_track_entry_size);
       buf += audio_track_entry_size;
     }
 
     if (has_video) {
       memcpy(buf, video_track_entry.get(), video_track_entry_size);
       buf += video_track_entry_size;
     }
   }
 
-  void SetupAVFormatContext(bool has_audio, bool has_video) {
-    int i = 0;
-    format_context_.streams = new AVStream *[MAX_CODECS_INDEX];
-    if (has_audio) {
-      format_context_.streams[i] = &streams_[i];
-      streams_[i].codec = &codecs_[AUDIO];
-      streams_[i].duration = 100;
-      streams_[i].time_base.den = base::Time::kMicrosecondsPerSecond;
-      streams_[i].time_base.num = 1;
-      i++;
-    }
-
-    if (has_video) {
-      format_context_.streams[i] = &streams_[i];
-      streams_[i].codec = &codecs_[VIDEO];
-      streams_[i].duration = 100;
-      streams_[i].time_base.den = base::Time::kMicrosecondsPerSecond;
-      streams_[i].time_base.num = 1;
-      i++;
-    }
-
-    format_context_.nb_streams = i;
-  }
-
-void InitDemuxer(bool has_audio, bool has_video) {
+  void InitDemuxer(bool has_audio, bool has_video) {
     EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
         .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_),
                         Return(0)));
 
     EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
         .WillOnce(Return(0));
 
     EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
 
     EXPECT_CALL(mock_ffmpeg_, AVRegisterLockManager(_))
         .WillRepeatedly(Return(0));
 
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
     CreateInfoTracks(has_audio, has_video, &info_tracks, &info_tracks_size);
 
     SetupAVFormatContext(has_audio, has_video);
 
     EXPECT_EQ(demuxer_->Init(info_tracks.get(), info_tracks_size),
               has_audio || has_video);
   }
 
+  void ShutdownDemuxer() {
+    if (demuxer_) {
+      demuxer_->Shutdown();
+    }
+
+    if (format_context_.streams) {
+      delete[] format_context_.streams;
+      format_context_.streams = NULL;
+      format_context_.nb_streams = 0;
+    }
+  }
+
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode) {
     uint8 data[] = { 0x00 };
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
   MockFFmpeg mock_ffmpeg_;
 
   AVFormatContext format_context_;
   AVCodecContext codecs_[MAX_CODECS_INDEX];
   AVStream streams_[MAX_CODECS_INDEX];
 
   scoped_refptr<ChunkDemuxer> demuxer_;
 
  private:
+  void SetupAVFormatContext(bool has_audio, bool has_video) {
+    int i = 0;
+    format_context_.streams = new AVStream*[MAX_CODECS_INDEX];
+    if (has_audio) {
+      format_context_.streams[i] = &streams_[i];
+      streams_[i].codec = &codecs_[AUDIO];
+      streams_[i].duration = 100;
+      streams_[i].time_base.den = base::Time::kMicrosecondsPerSecond;
+      streams_[i].time_base.num = 1;
+      i++;
+    }
+
+    if (has_video) {
+      format_context_.streams[i] = &streams_[i];
+      streams_[i].codec = &codecs_[VIDEO];
+      streams_[i].duration = 100;
+      streams_[i].time_base.den = base::Time::kMicrosecondsPerSecond;
+      streams_[i].time_base.num = 1;
+      i++;
+    }
+
+    format_context_.nb_streams = i;
+  }
+
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
   // Test no streams, audio-only, video-only, and audio & video scenarios.
   for (int i = 0; i < 4; i++) {
     bool has_audio = (i & 0x1) != 0;
     bool has_video = (i & 0x2) != 0;
 
     demuxer_ = new ChunkDemuxer();
     InitDemuxer(has_audio, has_video);
     EXPECT_EQ(demuxer_->GetStream(DemuxerStream::AUDIO).get() != NULL,
               has_audio);
     EXPECT_EQ(demuxer_->GetStream(DemuxerStream::VIDEO).get() != NULL,
               has_video);
-    demuxer_->Shutdown();
+    ShutdownDemuxer();
     demuxer_ = NULL;
   }
 }
 
 // Makes sure that  Seek() reports an error if Shutdown()
 // is called before the first cluster is passed to the demuxer.
 TEST_F(ChunkDemuxerTest, TestShutdownBeforeFirstSeekCompletes) {
   InitDemuxer(true, true);
 
   demuxer_->Seek(base::TimeDelta::FromSeconds(0),
@@ skipping 176 matching lines @@
 
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> clusterE(cb.Finish());
 
   EXPECT_FALSE(demuxer_->AddData(clusterE->data(), clusterE->size()));
 }
 
 }  // namespace media