Make AudioDecoderConfig copyable.

media/filters/source_buffer_stream.cc

 // Copyright (c) 2012 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/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
-#include "base/stl_util.h"
+
 namespace media {
 // Helper class representing a range of buffered data. All buffers in a
 // SourceBufferRange are ordered sequentially in presentation order with no
 // gaps.
 class SourceBufferRange {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
 
   // Returns the maximum distance in time between any buffer seen in this
   // stream. Used to estimate the duration of a buffer if its duration is not
@@ skipping 275 matching lines @@
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultAudioMemoryLimit),
       config_change_pending_(false) {
   DCHECK(audio_config.IsValidConfig());
-  audio_configs_.push_back(new AudioDecoderConfig());
-  audio_configs_.back()->CopyFrom(audio_config);
+  audio_configs_.push_back(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
                                        const LogCB& log_cb)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultVideoMemoryLimit),
       config_change_pending_(false) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
-
-  STLDeleteElements(&audio_configs_);
 }
 
 void SourceBufferStream::OnNewMediaSegment(
     base::TimeDelta media_segment_start_time) {
   media_segment_start_time_ = media_segment_start_time;
   new_media_segment_ = true;
 
   RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
 
@@ skipping 684 matching lines @@
   return ranges;
 }
 
 bool SourceBufferStream::IsEndSelected() const {
   return ranges_.empty() || selected_range_ == ranges_.back();
 }
 
 const AudioDecoderConfig& SourceBufferStream::GetCurrentAudioDecoderConfig() {
   if (config_change_pending_)
     CompleteConfigChange();
-  return *audio_configs_[current_config_index_];
+  return audio_configs_[current_config_index_];
 }
 
 const VideoDecoderConfig& SourceBufferStream::GetCurrentVideoDecoderConfig() {
   if (config_change_pending_)
     CompleteConfigChange();
   return video_configs_[current_config_index_];
 }
 
 base::TimeDelta SourceBufferStream::GetMaxInterbufferDistance() const {
   if (max_interbuffer_distance_ == kNoTimestamp())
     return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
   return max_interbuffer_distance_;
 }
 
 bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(!audio_configs_.empty());
   DCHECK(video_configs_.empty());
   DVLOG(3) << "UpdateAudioConfig.";
 
-  if (audio_configs_[0]->codec() != config.codec()) {
+  if (audio_configs_[0].codec() != config.codec()) {
     MEDIA_LOG(log_cb_) << "Audio codec changes not allowed.";
     return false;
   }
 
-  if (audio_configs_[0]->samples_per_second() != config.samples_per_second()) {
+  if (audio_configs_[0].samples_per_second() != config.samples_per_second()) {
     MEDIA_LOG(log_cb_) << "Audio sample rate changes not allowed.";
     return false;
   }
 
-  if (audio_configs_[0]->channel_layout() != config.channel_layout()) {
+  if (audio_configs_[0].channel_layout() != config.channel_layout()) {
     MEDIA_LOG(log_cb_) << "Audio channel layout changes not allowed.";
     return false;
   }
 
-  if (audio_configs_[0]->bits_per_channel() != config.bits_per_channel()) {
+  if (audio_configs_[0].bits_per_channel() != config.bits_per_channel()) {
     MEDIA_LOG(log_cb_) << "Audio bits per channel changes not allowed.";
     return false;
   }
 
-  if (audio_configs_[0]->is_encrypted() != config.is_encrypted()) {
+  if (audio_configs_[0].is_encrypted() != config.is_encrypted()) {
     MEDIA_LOG(log_cb_) << "Audio encryption changes not allowed.";
     return false;
   }
 
   // Check to see if the new config matches an existing one.
   for (size_t i = 0; i < audio_configs_.size(); ++i) {
-    if (config.Matches(*audio_configs_[i])) {
+    if (config.Matches(audio_configs_[i])) {
       append_config_index_ = i;
       return true;
     }
   }
 
   // No matches found so let's add this one to the list.
   append_config_index_ = audio_configs_.size();
   DVLOG(2) << "New audio config - index: " << append_config_index_;
   audio_configs_.resize(audio_configs_.size() + 1);
-  audio_configs_[append_config_index_] = new AudioDecoderConfig();
-  audio_configs_[append_config_index_]->CopyFrom(config);
+  audio_configs_[append_config_index_] = config;
   return true;
 }
 
 bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
   DCHECK(!video_configs_.empty());
   DCHECK(audio_configs_.empty());
   DVLOG(3) << "UpdateVideoConfig.";
 
   if (video_configs_[0].is_encrypted() != config.is_encrypted()) {
     MEDIA_LOG(log_cb_) << "Video Encryption changes not allowed.";
@@ skipping 614 matching lines @@
   return ComputeFudgeRoom(GetApproximateDuration());
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media