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

media/filters/video_renderer_base.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/bind.h"
 #include "base/callback.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/callback.h"
 #include "media/base/filter_host.h"
@@ skipping 10 matching lines @@
 // audio renderer to catch up faster.  A lower value will be a smoother frame
 // rate, but results in the video being out of sync for longer.
 static const int64 kMaxSleepMilliseconds = 60;
 
 // The number of milliseconds to idle when we do not have anything to do.
 // Nothing special about the value, other than we're being more OS-friendly
 // than sleeping for 1 millisecond.
 static const int kIdleMilliseconds = 10;
 
 VideoRendererBase::VideoRendererBase()
-    : width_(0),
-      height_(0),
-      surface_format_(VideoFrame::INVALID),
-      frame_available_(&lock_),
+    : frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_reads_(0),
       pending_paint_(false),
       pending_paint_with_last_available_(false),
       playback_rate_(0) {
 }
 
 VideoRendererBase::~VideoRendererBase() {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kUninitialized || state_ == kStopped);
 }
 
-// static
-bool VideoRendererBase::ParseMediaFormat(
-    const MediaFormat& media_format,
-    VideoFrame::Format* surface_format_out,
-    int* width_out, int* height_out) {
-  int surface_format;
-  if (!media_format.GetAsInteger(MediaFormat::kSurfaceFormat, &surface_format))
-    return false;
-  if (surface_format_out)
-    *surface_format_out = static_cast<VideoFrame::Format>(surface_format);
-
-  int width, height;
-  if (!media_format.GetAsInteger(MediaFormat::kWidth, &width))
-    return false;
-  if (!media_format.GetAsInteger(MediaFormat::kHeight, &height))
-    return false;
-  if (width_out) *width_out = width;
-  if (height_out) *height_out = height;
-  return true;
-}
-
 void VideoRendererBase::Play(FilterCallback* callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   scoped_ptr<FilterCallback> c(callback);
   state_ = kPlaying;
   callback->Run();
 }
 
 void VideoRendererBase::Pause(FilterCallback* callback) {
   base::AutoLock auto_lock(lock_);
@@ skipping 87 matching lines @@
   decoder_ = decoder;
   AutoCallbackRunner done_runner(callback);
 
   statistics_callback_.reset(stats_callback);
 
   decoder_->set_consume_video_frame_callback(
       base::Bind(&VideoRendererBase::ConsumeVideoFrame,
                  base::Unretained(this)));
 
   // Notify the pipeline of the video dimensions.
-  if (!ParseMediaFormat(decoder->media_format(),
-                        &surface_format_,
-                        &width_, &height_)) {
-    EnterErrorState_Locked(PIPELINE_ERROR_INITIALIZATION_FAILED);
-    return;
-  }
-  host()->SetVideoSize(width_, height_);
+  host()->SetVideoSize(decoder_->width(), decoder_->height());
 
   // Initialize the subclass.
   // TODO(scherkus): do we trust subclasses not to do something silly while
   // we're holding the lock?
   if (!OnInitialize(decoder)) {
     EnterErrorState_Locked(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
@@ skipping 279 matching lines @@
   } else if (state_ == kFlushing && pending_reads_ == 0 && !pending_paint_) {
     OnFlushDone();
   }
 
   if (new_frame_available) {
     base::AutoUnlock auto_unlock(lock_);
     OnFrameAvailable();
   }
 }
 
-VideoDecoder* VideoRendererBase::GetDecoder() {
-  return decoder_.get();
-}
-
 void VideoRendererBase::ReadInput(scoped_refptr<VideoFrame> frame) {
   // We should never return empty frames or EOS frame.
   DCHECK(frame.get() && !frame->IsEndOfStream());
 
   decoder_->ProduceVideoFrame(frame);
   ++pending_reads_;
 }
 
 void VideoRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
@@ skipping 129 matching lines @@
 void VideoRendererBase::DoStopOrErrorFlush_Locked() {
   DCHECK(!pending_paint_);
   DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
   FlushBuffers();
   last_available_frame_ = NULL;
   DCHECK_EQ(pending_reads_, 0);
 }
 
 }  // namespace media