Changed mft_h264_decoder's API to match with video_decode_engine.h. Also chan...

media/filters/video_decode_engine.h

 // Copyright (c) 2010 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_FILTERS_VIDEO_DECODE_ENGINE_H_
 #define MEDIA_FILTERS_VIDEO_DECODE_ENGINE_H_
 
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "media/base/video_frame.h"
@@ skipping 54 matching lines @@
 
   // Initial Stream Info. Only part of them could be valid.
   // If they are not valid, Engine should update with OnFormatChange.
   VideoStreamInfo stream_info_;
 };
 
 class VideoDecodeEngine : public base::RefCountedThreadSafe<VideoDecodeEngine> {
  public:
   struct EventHandler {
    public:
+    virtual ~EventHandler() {}

[Alpha Left Google, 2010/08/24 23:03:33]

good catch.

     virtual void OnInitializeComplete(const VideoCodecInfo& info) = 0;
     virtual void OnUninitializeComplete() = 0;
     virtual void OnFlushComplete() = 0;
     virtual void OnSeekComplete() = 0;
     virtual void OnError() = 0;
     virtual void OnFormatChange(VideoStreamInfo stream_info) = 0;
     virtual void OnEmptyBufferCallback(scoped_refptr<Buffer> buffer) = 0;
     virtual void OnFillBufferCallback(scoped_refptr<VideoFrame> frame) = 0;
   };
 
   VideoDecodeEngine() {}
   virtual ~VideoDecodeEngine() {}
 
   // Initialized the engine with specified configuration. |message_loop| could
   // be NULL if every operation is synchronous. Engine should call the
   // EventHandler::OnInitializeDone() no matter finished successfully or not.
   // TODO(jiesun): remove message_loop and create thread inside openmax engine?
   // or create thread in GpuVideoDecoder and pass message loop here?
   virtual void Initialize(MessageLoop* message_loop,
                           EventHandler* event_handler,
                           const VideoCodecConfig& config) = 0;
 
   // Uninitialize the engine. Engine should destroy all resources and call
-  // EventHandler::OnInitializeDone().
+  // EventHandler::OnUninitializeComplete().
   virtual void Uninitialize() = 0;
 
   // Flush the engine. Engine should return all the buffers to owner ( which
   // could be itself. ) then call EventHandler::OnFlushDone().
   virtual void Flush() = 0;
 
   // Used in openmax to InitialReadBuffers().
   virtual void Seek() = 0;  // TODO(jiesun): Do we need this?
 
   // Buffer exchange method for input and output stream.
   // These functions and callbacks could be used in two scenarios for both
   // input and output streams:
   // 1. Engine provide buffers.
   // 2. Outside party provide buffers.
   // The currently planned engine implementation:
   // 1. provides the input buffer request inside engine through
   // |EmptyThisBufferCallback|. The engine implementation has better knowledge
   // of the decoder reordering delay and jittery removal requirements. Input
   // buffers are returned into engine through |EmptyThisBuffer|.
   // 2. Output buffers are provided from outside the engine, and feed into
   // engine through |FillThisBuffer|. Output buffers are returned to outside
   // by |FillThisBufferCallback|.
   virtual void EmptyThisBuffer(scoped_refptr<Buffer> buffer) = 0;
   virtual void FillThisBuffer(scoped_refptr<VideoFrame> frame) = 0;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VIDEO_DECODE_ENGINE_H_