Replace VideoDecoder::media_format() with significantly simpler width()/height() methods.

media/filters/ffmpeg_video_decoder.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 "media/filters/ffmpeg_video_decoder.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/task.h"
 #include "media/base/callback.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
-#include "media/base/media_format.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 #include "media/video/video_decode_context.h"
 
 namespace media {
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(MessageLoop* message_loop,
                                        VideoDecodeContext* decode_context)
     : message_loop_(message_loop),
@@ skipping 62 matching lines @@
 }
 
 void FFmpegVideoDecoder::OnInitializeComplete(const VideoCodecInfo& info) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(initialize_callback_.get());
 
   info_ = info;
   AutoCallbackRunner done_runner(initialize_callback_.release());
 
   if (info.success) {
-    media_format_.SetAsInteger(MediaFormat::kWidth,
-                               info.stream_info.surface_width);
-    media_format_.SetAsInteger(MediaFormat::kHeight,
-                               info.stream_info.surface_height);
-    media_format_.SetAsInteger(
-        MediaFormat::kSurfaceFormat,
-        static_cast<int>(info.stream_info.surface_format));
     state_ = kNormal;
   } else {
     host()->SetError(PIPELINE_ERROR_DECODE);
   }
 }
 
 void FFmpegVideoDecoder::Stop(FilterCallback* callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
@@ skipping 150 matching lines @@
   // TODO(ajwong): This push logic, along with the pop logic below needs to
   // be reevaluated to correctly handle decode errors.
   if (state_ == kNormal) {
     pts_stream_.EnqueuePts(buffer.get());
   }
 
   // Otherwise, attempt to decode a single frame.
   decode_engine_->ConsumeVideoSample(buffer);
 }
 
-const MediaFormat& FFmpegVideoDecoder::media_format() {
-  return media_format_;
-}
-
 void FFmpegVideoDecoder::ProduceVideoFrame(
     scoped_refptr<VideoFrame> video_frame) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &FFmpegVideoDecoder::ProduceVideoFrame, video_frame));
     return;
   }
 
@@ skipping 56 matching lines @@
 
   demuxer_stream_->Read(base::Bind(&FFmpegVideoDecoder::OnReadComplete,
                                    this));
 }
 
 bool FFmpegVideoDecoder::ProvidesBuffer() {
   DCHECK(info_.success);
   return info_.provides_buffers;
 }
 
+int FFmpegVideoDecoder::width() {
+  DCHECK(info_.success);
+  return info_.stream_info.surface_width;
+}
+
+int FFmpegVideoDecoder::height() {
+  DCHECK(info_.success);
+  return info_.stream_info.surface_height;
+}
+
 void FFmpegVideoDecoder::FlushBuffers() {
   while (!frame_queue_flushed_.empty()) {
     scoped_refptr<VideoFrame> video_frame;
     video_frame = frame_queue_flushed_.front();
     frame_queue_flushed_.pop_front();
 
     // Depends on who own the buffers, we either return it to the renderer
     // or return it to the decode engine.
     if (ProvidesBuffer())
       decode_engine_->ProduceVideoFrame(video_frame);
     else
       VideoFrameReady(video_frame);
   }
 }
 
 void FFmpegVideoDecoder::SetVideoDecodeEngineForTest(
     VideoDecodeEngine* engine) {
   decode_engine_.reset(engine);
 }
 
 }  // namespace media