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

content/renderer/media/rtc_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 "content/renderer/media/rtc_video_decoder.h"
 
 #include <deque>
 
 #include "base/task.h"
 #include "media/base/callback.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
 #include "media/base/limits.h"
-#include "media/base/media_format.h"
 #include "media/base/video_frame.h"
 
 using media::DemuxerStream;
 using media::FilterCallback;
 using media::FilterStatusCB;
 using media::kNoTimestamp;
 using media::Limits;
-using media::MediaFormat;
 using media::PIPELINE_OK;
 using media::StatisticsCallback;
 using media::VideoDecoder;
 using media::VideoFrame;
 
 RTCVideoDecoder::RTCVideoDecoder(MessageLoop* message_loop,
                                  const std::string& url)
     : message_loop_(message_loop),
       width_(176),
       height_(144),
       url_(url),
       state_(kUnInitialized) {
 }
 
-RTCVideoDecoder::~RTCVideoDecoder() {
-}
+RTCVideoDecoder::~RTCVideoDecoder() {}
 
 void RTCVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
                                  FilterCallback* filter_callback,
                                  StatisticsCallback* stat_callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &RTCVideoDecoder::Initialize,
                           make_scoped_refptr(demuxer_stream),
                           filter_callback, stat_callback));
     return;
   }
 
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   lock_.Acquire();
   frame_queue_available_.clear();
   lock_.Release();
-  media_format_.SetAsInteger(MediaFormat::kWidth, width_);
-  media_format_.SetAsInteger(MediaFormat::kHeight, height_);
-  media_format_.SetAsInteger(MediaFormat::kSurfaceType,
-                             static_cast<int>(VideoFrame::YV12));
 
   state_ = kNormal;
 
   filter_callback->Run();
   delete filter_callback;
 
   // TODO(acolwell): Implement stats.
   delete stat_callback;
 }
 
@@ skipping 58 matching lines @@
   // so that the renderer can complete the seeking
   for (size_t i = 0; i < Limits::kMaxVideoFrames; ++i) {
     VideoFrameReady(VideoFrame::CreateBlackFrame(width_, height_));
   }
 
   state_ = kNormal;
 
   cb.Run(PIPELINE_OK);
 }
 
-const MediaFormat& RTCVideoDecoder::media_format() {
-  return media_format_;
-}
-
 void RTCVideoDecoder::ProduceVideoFrame(
     scoped_refptr<VideoFrame> video_frame) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &RTCVideoDecoder::ProduceVideoFrame, video_frame));
     return;
   }
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   base::AutoLock auto_lock(lock_);
   frame_queue_available_.push_back(video_frame);
 }
 
 bool RTCVideoDecoder::ProvidesBuffer() {
   return true;
 }
 
+int RTCVideoDecoder::width() {
+  return width_;
+}
+
+int RTCVideoDecoder::height() {
+  return height_;
+}
+
 bool RTCVideoDecoder::SetSize(int width, int height, int reserved) {
   width_ = width;
   height_ = height;
 
-  media_format_.SetAsInteger(MediaFormat::kWidth, width_);
-  media_format_.SetAsInteger(MediaFormat::kHeight, height_);
   host()->SetVideoSize(width_, height_);
   return true;
 }
 
 bool RTCVideoDecoder::RenderFrame(const cricket::VideoFrame* frame) {
   DCHECK(frame);
 
   if (state_ != kNormal)
     return true;
 
@@ skipping 49 matching lines @@
         FROM_HERE,
         NewRunnableMethod(this,
                           &RTCVideoDecoder::VideoFrameReady,
                           video_frame));
   } else {
     VideoFrameReady(video_frame);
   }
 
   return true;
 }