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

media/base/mock_media_filters.h

 // Copyright (c) 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.
 
 #ifndef MEDIA_BASE_MOCK_MEDIA_FILTERS_H_
 #define MEDIA_BASE_MOCK_MEDIA_FILTERS_H_
 
 #include <string>
 
 #include "base/waitable_event.h"
@@ skipping 106 matching lines @@
         host_->Error(PIPELINE_ERROR_URL_NOT_FOUND);
         return false;
       case MOCK_DATA_SOURCE_INIT_RETURN_FALSE:
         return false;
       default:
         NOTREACHED();
         return false;
     }
   }
 
-  virtual const MediaFormat* GetMediaFormat() {
-    return &media_format_;
+  virtual const MediaFormat& media_format() {
+    return media_format_;
   }
 
   virtual size_t Read(uint8* data, size_t size) {
     size_t read = static_cast<size_t>(config_->media_total_bytes - position_);
     if (size < read) {
       read = size;
     }
     memset(data, config_->data_source_value, read);
     return read;
   }
@@ skipping 64 matching lines @@
                                 config->compressed_audio_mime_type);
     } else {
       media_format_.SetAsString(MediaFormat::kMimeType,
                                 config->compressed_video_mime_type);
       media_format_.SetAsInteger(MediaFormat::kWidth, config->video_width);
       media_format_.SetAsInteger(MediaFormat::kHeight, config->video_height);
     }
   }
 
   // Implementation of DemuxerStream.
-  virtual const MediaFormat* GetMediaFormat() {
-    return &media_format_;
+  virtual const MediaFormat& media_format() {
+    return media_format_;
   }
 
   virtual void Read(Assignable<Buffer>* buffer) {
     NOTREACHED();  // TODO(ralphl): fix me!!
   }
 
  private:
   virtual ~MockDemuxerStream() {}
 
   MediaFormat media_format_;
@@ skipping 67 matching lines @@
 
 //------------------------------------------------------------------------------
 
 class MockAudioDecoder : public AudioDecoder {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
     return new FilterFactoryImpl1<MockAudioDecoder,
                                   const MockFilterConfig*>(config);
   }
 
-  static bool IsMediaFormatSupported(const MediaFormat* media_format) {
+  static bool IsMediaFormatSupported(const MediaFormat& media_format) {
     return true;  // TODO(ralphl): check for a supported format.
   }
 
   explicit MockAudioDecoder(const MockFilterConfig* config) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               config->uncompressed_audio_mime_type);
   }
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of AudioDecoder.
   virtual bool Initialize(DemuxerStream* stream) {
     host_->InitializationComplete();
     return true;
   }
 
-  virtual const MediaFormat* GetMediaFormat() {
-    return &media_format_;
+  virtual const MediaFormat& media_format() {
+    return media_format_;
   }
 
   virtual void Read(Assignable<Buffer>* buffer) {
     // TODO(ralphl): implement mock read.
     NOTREACHED();
   }
 
  private:
   virtual ~MockAudioDecoder() {}
 
   MediaFormat media_format_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
 };
 
 //------------------------------------------------------------------------------
 
 class MockAudioRenderer : public AudioRenderer {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
     return new FilterFactoryImpl1<MockAudioRenderer,
                                   const MockFilterConfig*>(config);
   }
 
-  static bool IsMediaFormatSupported(const MediaFormat* media_format) {
+  static bool IsMediaFormatSupported(const MediaFormat& media_format) {
     return true;  // TODO(ralphl): check for a supported format
   }
 
   explicit MockAudioRenderer(const MockFilterConfig* config) {}
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of AudioRenderer.
   virtual bool Initialize(AudioDecoder* decoder) {
@@ skipping 11 matching lines @@
 
 //------------------------------------------------------------------------------
 
 class MockVideoDecoder : public VideoDecoder {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
     return new FilterFactoryImpl1<MockVideoDecoder,
                                   const MockFilterConfig*>(config);
   }
 
-  static bool IsMediaFormatSupported(const MediaFormat* media_format) {
+  static bool IsMediaFormatSupported(const MediaFormat& media_format) {
     return true;  // TODO(ralphl): check for a supported format.
   }
 
   // Helper function that initializes a YV12 frame with white and black scan
   // lines based on the |white_to_black| parameter.  If 0, then the entire
   // frame will be black, if 1 then the entire frame will be white.
   static void InitializeYV12Frame(VideoFrame* frame, double white_to_black) {
     VideoSurface surface;
     if (!frame->Lock(&surface)) {
       ADD_FAILURE();
@@ skipping 29 matching lines @@
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of VideoDecoder.
   virtual bool Initialize(DemuxerStream* stream) {
     host_->InitializationComplete();
     return true;
   }
 
-  virtual const MediaFormat* GetMediaFormat() {
-    return &media_format_;
+  virtual const MediaFormat& media_format() {
+    return media_format_;
   }
 
   virtual void Read(Assignable<VideoFrame>* buffer) {
     buffer->AddRef();
     host_->PostTask(NewRunnableMethod(this, &MockVideoDecoder::DoRead, buffer));
   }
 
  private:
   virtual ~MockVideoDecoder() {}
 
@@ skipping 35 matching lines @@
 
 //------------------------------------------------------------------------------
 
 class MockVideoRenderer : public VideoRenderer {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
     return new FilterFactoryImpl1<MockVideoRenderer,
                                   const MockFilterConfig*>(config);
   }
 
-  static bool IsMediaFormatSupported(const MediaFormat* media_format) {
+  static bool IsMediaFormatSupported(const MediaFormat& media_format) {
     return true;  // TODO(ralphl): check for a supported format
   }
 
   explicit MockVideoRenderer(const MockFilterConfig* config)
       : config_(config) {
   }
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
@@ skipping 92 matching lines @@
   base::WaitableEvent event_;
   bool callback_success_status_;
   bool waiting_for_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InitializationHelper);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MOCK_MEDIA_FILTERS_H_