Lots of files touched for a very simple change. Everywhere we used a const M...

media/base/pipeline_impl.cc

 // Copyright (c) 2006-2009 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/compiler_specific.h"
 #include "media/base/filter_host_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/pipeline_impl.h"
 
 namespace media {
@@ skipping 400 matching lines @@
     message_loop()->Quit();
   }
 }
 
 template <class Decoder, class Renderer>
 void PipelineThread::Render(FilterFactory* filter_factory, Demuxer* demuxer) {
   DCHECK(PipelineOk());
   const std::string major_mime_type = Decoder::major_mime_type();
   const int num_outputs = demuxer->GetNumberOfStreams();
   for (int i = 0; i < num_outputs; ++i) {
-    scoped_refptr<DemuxerStream> demuxer_stream = demuxer->GetStream(i);
-    const MediaFormat* stream_format = demuxer_stream->GetMediaFormat();
+    scoped_refptr<DemuxerStream> stream = demuxer->GetStream(i);
     std::string value;
-    if (stream_format->GetAsString(MediaFormat::kMimeType, &value) &&
+    if (stream->media_format().GetAsString(MediaFormat::kMimeType, &value) &&
         0 == value.compare(0, major_mime_type.length(), major_mime_type)) {
       scoped_refptr<Decoder> decoder =
-          CreateFilter<Decoder, DemuxerStream>(filter_factory, demuxer_stream);
+          CreateFilter<Decoder, DemuxerStream>(filter_factory, stream);
       if (PipelineOk()) {
         DCHECK(decoder);
         CreateFilter<Renderer, Decoder>(filter_factory, decoder);
       }
       if (PipelineOk()) {
         pipeline_->InsertRenderedMimeType(major_mime_type);
       }
       break;
     }
   }
@@ skipping 55 matching lines @@
        iter != filter_hosts_.end() && NULL == *filter_out;
        iter++) {
     (*iter)->GetFilter(filter_out);
   }
 }
 
 template <class Filter, class Source>
 scoped_refptr<Filter> PipelineThread::CreateFilter(
     FilterFactory* filter_factory,
     Source source,
-    const MediaFormat* media_format) {
+    const MediaFormat& media_format) {
   DCHECK(PipelineOk());
   scoped_refptr<Filter> filter = filter_factory->Create<Filter>(media_format);
   if (!filter) {
     Error(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
   } else {
     DCHECK(!host_initializing_);
     host_initializing_ = new FilterHostImpl(this, filter.get());
     if (NULL == host_initializing_) {
       Error(PIPELINE_ERROR_OUT_OF_MEMORY);
     } else {
@@ skipping 28 matching lines @@
     filter = NULL;
   }
   return filter;
 }
 
 scoped_refptr<DataSource> PipelineThread::CreateDataSource(
     FilterFactory* filter_factory, const std::string& url) {
   MediaFormat url_format;
   url_format.SetAsString(MediaFormat::kMimeType, mime_type::kURL);
   url_format.SetAsString(MediaFormat::kURL, url);
-  return CreateFilter<DataSource>(filter_factory, url, &url_format);
+  return CreateFilter<DataSource>(filter_factory, url, url_format);
 }
 
 // Called as a result of destruction of the thread.
 void PipelineThread::WillDestroyCurrentMessageLoop() {
   while (!filter_hosts_.empty()) {
     delete filter_hosts_.back();
     filter_hosts_.pop_back();
   }
 }
 
 }  // namespace media